/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.11
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

#include <cmath>
#ifdef _XOPEN_SOURCE
#undef _XOPEN_SOURCE
#endif
#ifdef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif


#define SWIG_PYTHON_OUTPUT_TUPLE



#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_module_name    "casadi"

#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  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(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG
#else
# include <Python.h>
#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

/* 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 to return 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)
#define SWIG_ERROR                 (-1)
#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 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(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.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  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

/*  Errors in SWIG */
#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 PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#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


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *cstr;
  char *newstr;
  Py_ssize_t len;
  str = PyUnicode_AsUTF8String(str);
  PyBytes_AsStringAndSize(str, &cstr, &len);
  newstr = (char *) malloc(len+1);
  memcpy(newstr, cstr, len+1);
  Py_XDECREF(str);
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#endif


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

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
  long result = 0;
  PyObject *i = PyNumber_Int(x);
  if (i) {
    result = PyInt_AsLong(i);
    Py_DECREF(i);
  }
  return result;
}
#endif

#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif

#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op)				\
  do { 						\
    if (op) {					\
      int vret = visit((op), arg);		\
      if (vret)					\
        return vret;				\
    }						\
  } while (0)
#endif

#if PY_VERSION_HEX < 0x02030000
typedef struct {
  PyTypeObject type;
  PyNumberMethods as_number;
  PyMappingMethods as_mapping;
  PySequenceMethods as_sequence;
  PyBufferProcs as_buffer;
  PyObject *name, *slots;
} PyHeapTypeObject;
#endif

#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     (PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#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) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

#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)
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
#      define SWIG_PYTHON_USE_GIL
#    endif
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    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;
  char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
  return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
  return NULL;
}
#endif

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

/* 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) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  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);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

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

/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

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

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

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#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;
  return data ? data->implicitconv : 0;
}

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;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
#if (PY_VERSION_HEX < 0x02020000)
      data->newraw = 0;
#else
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
      data->delargs = !(flags & (METH_O));
#else
      data->delargs = 0;
#endif
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

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

/* =============== 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_INCREF(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) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *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 *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
  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 (v->next) {
# ifdef METH_NOARGS
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# 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
  }
  return repr;  
}

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

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 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 *val = NULL, *type = NULL, *tb = NULL;
      PyErr_Fetch(&val, &type, &tb);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(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(val, type, tb);

      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(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

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

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  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 (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#else
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

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 */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyObject",               /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,				    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
#else
      (getattrfunc)0,                       /* tp_getattr */
#endif
      (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 */
#if PY_VERSION_HEX >= 0x02020000
      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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                    /* tp_prev */
#endif
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpyobject_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
#endif
  }
  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;
  }
  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 int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->ty->name,fp); 
  fputs(">", fp);
  return 0; 
}
  
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((char *)v->pack, (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 = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyPacked",               /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      (printfunc)SwigPyPacked_print,        /* tp_print */
      (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 */
#if PY_VERSION_HEX >= 0x02020000
      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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                    /* tp_prev */
#endif
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpypacked_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
#endif
  }
  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
 * ----------------------------------------------------------------------------- */

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

static PyObject *swig_this = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (swig_this == NULL)
    swig_this = _SWIG_This();
  return swig_this;
}

/* #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) && (PY_VERSION_HEX >= 0x02030000))
  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 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 (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 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;
    
    /* 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;
    if (ty) {
      swig_cast_info *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;
      }
    } else {
      *ptr = vptr;
    }
    return SWIG_OK;
  }
}

/* Convert a packed value 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)
{
#if (PY_VERSION_HEX >= 0x02020000)
  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;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    if (inst) {
      PyObject_SetAttr(inst, SWIG_This(), swig_this);
      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    }
#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;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst = 0;
  PyObject *dict = PyDict_New();
  if (dict) {
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


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) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    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
      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

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

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

SWIGRUNTIME void
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
  swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  swig_this = 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((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
#ifdef SWIGPY_USE_CAPSULE
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#else
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#endif
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

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) {
#ifdef SWIGPY_USE_CAPSULE
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
      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) {
      char *tmp;
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
      } else {
	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      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);
          SWIG_Python_str_DelForPy3(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();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

/* Convert Python arguments to a type description
 *
 * You must call SWIG_Python_str_DelForPy3() on the result after usage
*/
SWIGRUNTIME const char*
SWIG_Python_ArgsTypeDesc(PyObject* args) {
  const char *res_char = 0;
#if PY_VERSION_HEX < 0x03070000
  PyObject* module = PyImport_AddModule(SWIG_module_name);
#else
  PyObject* name = PyString_FromString(SWIG_module_name);
  PyObject* module = PyImport_GetModule(name);
  Py_DECREF(name);
#endif
  if (!module) {
    if (PyErr_Occurred()) PyErr_Clear();
    return res_char;
  }
  PyObject* dict = PyModule_GetDict(module);
  if (!dict) return res_char;
  PyObject* fun = PyDict_GetItemString(dict, (char*)"swigtypeconvertor");
  if (fun && PyCallable_Check(fun)) {
    PyObject* res = PyObject_CallObject(fun, args);
    if (!res) return res_char;
    PyObject* res_str = PyObject_Repr(res);
    if (!res) { Py_DECREF(res); return res_char;}
    res_char = SWIG_Python_str_AsChar(res_str);
    if (!res_char) { Py_DECREF(res_str); Py_DECREF(res); return res_char;}
    Py_DECREF(res_str);
    Py_DECREF(res);
  }
  return res_char;
}

/* Convert Python arguments to a type description
 *
 * You must call SWIG_Python_str_DelForPy3() on the result after usage
*/
SWIGRUNTIME const char*
SWIG_Python_ArgsTypeDesc_funpack(int nobjs, PyObject** swig_obj) {
  PyObject *t = PyTuple_New(nobjs);
  for (int i=0;i<nobjs;++i) {
    PyTuple_SET_ITEM(t, i, swig_obj[i]);
  }
  const char* res = SWIG_Python_ArgsTypeDesc(t);
  Py_DECREF(t);
  return res;
}

#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);
    }
    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) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



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

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>


/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, what());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* unknown exception handler  */
  class UnknownExceptionHandler {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
        throw;
      } catch (DirectorException& e) {
        std::cerr << "SWIG Director exception caught:" << std::endl
                  << e.what() << std::endl;
      } catch (std::exception& e) {
        std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
        std::cerr << "Unknown exception caught." << std::endl;
      }

      std::cerr << std::endl
                << "Python interpreter traceback:" << std::endl;
      PyErr_Print();
      std::cerr << std::endl;

      std::cerr << "This exception was caught by the SWIG UnknownExceptionHandler." << std::endl
                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
                << std::endl
                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
      throw;
    }

  public:
    std::terminate_handler old;
    UnknownExceptionHandler(std::terminate_handler nh = handler) {
      old = std::set_terminate(nh);
    }

    ~UnknownExceptionHandler() {
      std::set_terminate(old);
    }
#endif
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

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

#define SWIGTYPE_p_AuxOut swig_types[0]
#define SWIGTYPE_p_Dict swig_types[1]
#define SWIGTYPE_p_MXDict swig_types[2]
#define SWIGTYPE_p_allocator_type swig_types[3]
#define SWIGTYPE_p_casadi__Callback swig_types[4]
#define SWIGTYPE_p_casadi__CasadiMeta swig_types[5]
#define SWIGTYPE_p_casadi__CodeGenerator swig_types[6]
#define SWIGTYPE_p_casadi__DaeBuilder swig_types[7]
#define SWIGTYPE_p_casadi__DeserializerBase swig_types[8]
#define SWIGTYPE_p_casadi__DeserializingStream swig_types[9]
#define SWIGTYPE_p_casadi__FileDeserializer swig_types[10]
#define SWIGTYPE_p_casadi__FileSerializer swig_types[11]
#define SWIGTYPE_p_casadi__Function swig_types[12]
#define SWIGTYPE_p_casadi__FunctionBuffer swig_types[13]
#define SWIGTYPE_p_casadi__GenericExpressionCommon swig_types[14]
#define SWIGTYPE_p_casadi__GenericMatrixCommon swig_types[15]
#define SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t swig_types[16]
#define SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t swig_types[17]
#define SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t swig_types[18]
#define SWIGTYPE_p_casadi__GenericType swig_types[19]
#define SWIGTYPE_p_casadi__GlobalOptions swig_types[20]
#define SWIGTYPE_p_casadi__Importer swig_types[21]
#define SWIGTYPE_p_casadi__IndexAbstraction swig_types[22]
#define SWIGTYPE_p_casadi__Linsol swig_types[23]
#define SWIGTYPE_p_casadi__MX swig_types[24]
#define SWIGTYPE_p_casadi__MatrixCommon swig_types[25]
#define SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t swig_types[26]
#define SWIGTYPE_p_casadi__MatrixT_double_t swig_types[27]
#define SWIGTYPE_p_casadi__MatrixT_long_long_t swig_types[28]
#define SWIGTYPE_p_casadi__MetaCon swig_types[29]
#define SWIGTYPE_p_casadi__MetaVar swig_types[30]
#define SWIGTYPE_p_casadi__NlpBuilder swig_types[31]
#define SWIGTYPE_p_casadi__Opti swig_types[32]
#define SWIGTYPE_p_casadi__OptiAdvanced swig_types[33]
#define SWIGTYPE_p_casadi__OptiCallback swig_types[34]
#define SWIGTYPE_p_casadi__OptiSol swig_types[35]
#define SWIGTYPE_p_casadi__PrintableCommon swig_types[36]
#define SWIGTYPE_p_casadi__SXElem swig_types[37]
#define SWIGTYPE_p_casadi__SerializerBase swig_types[38]
#define SWIGTYPE_p_casadi__SerializingStream swig_types[39]
#define SWIGTYPE_p_casadi__SharedObject swig_types[40]
#define SWIGTYPE_p_casadi__SharedObjectInternal swig_types[41]
#define SWIGTYPE_p_casadi__Slice swig_types[42]
#define SWIGTYPE_p_casadi__Sparsity swig_types[43]
#define SWIGTYPE_p_casadi__SparsityInterfaceCommon swig_types[44]
#define SWIGTYPE_p_casadi__StringDeserializer swig_types[45]
#define SWIGTYPE_p_casadi__StringSerializer swig_types[46]
#define SWIGTYPE_p_casadi__WeakRef swig_types[47]
#define SWIGTYPE_p_casadi__XmlFile swig_types[48]
#define SWIGTYPE_p_char swig_types[49]
#define SWIGTYPE_p_const_reference swig_types[50]
#define SWIGTYPE_p_difference_type swig_types[51]
#define SWIGTYPE_p_double swig_types[52]
#define SWIGTYPE_p_first_type swig_types[53]
#define SWIGTYPE_p_key_type swig_types[54]
#define SWIGTYPE_p_long_long swig_types[55]
#define SWIGTYPE_p_mapped_type swig_types[56]
#define SWIGTYPE_p_p_double swig_types[57]
#define SWIGTYPE_p_reference swig_types[58]
#define SWIGTYPE_p_second_type swig_types[59]
#define SWIGTYPE_p_size_type swig_types[60]
#define SWIGTYPE_p_std__initializer_listT_casadi__MX_t swig_types[61]
#define SWIGTYPE_p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t swig_types[62]
#define SWIGTYPE_p_std__invalid_argument swig_types[63]
#define SWIGTYPE_p_std__istream swig_types[64]
#define SWIGTYPE_p_std__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t swig_types[65]
#define SWIGTYPE_p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t swig_types[66]
#define SWIGTYPE_p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t swig_types[67]
#define SWIGTYPE_p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t swig_types[68]
#define SWIGTYPE_p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t swig_types[69]
#define SWIGTYPE_p_std__ostream swig_types[70]
#define SWIGTYPE_p_std__pairT_casadi__Slice_casadi__Slice_t swig_types[71]
#define SWIGTYPE_p_std__string swig_types[72]
#define SWIGTYPE_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t swig_types[73]
#define SWIGTYPE_p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t swig_types[74]
#define SWIGTYPE_p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t swig_types[75]
#define SWIGTYPE_p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t swig_types[76]
#define SWIGTYPE_p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t swig_types[77]
#define SWIGTYPE_p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t swig_types[78]
#define SWIGTYPE_p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t swig_types[79]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[80]
#define SWIGTYPE_p_value_type swig_types[81]
static swig_type_info *swig_types[83];
static swig_module_info swig_module = {swig_types, 82, 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) -------- */

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodernargs' option"
#endif
#ifndef METH_O
# error "This python version requires swig to be run with the '-nofastunpack' option"
#endif

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

#else
#  define SWIG_init    init_casadi

#endif
#define SWIG_name    "_casadi"

#define SWIGVERSION 0x030011 
#define SWIG_VERSION SWIGVERSION


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


#include <casadi/casadi.hpp>
#include <casadi/core/casadi_interrupt.hpp>


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


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
#if PY_VERSION_HEX >= 0x03010000
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#else
      return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
#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));
}


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


  namespace casadi {
    // Redirect printout
    static void pythonlogger(const char* s, std::streamsize num, bool error) {
      if (!casadi::InterruptHandler::is_main_thread()) {
        casadi::Logger::writeDefault(s, num, error);
        return;
      }
      int n = num;
      while (n>0) {
        if (error) {
          PySys_WriteStderr("%.*s", std::min(n, 1000), s);
        } else {
          PySys_WriteStdout("%.*s", std::min(n, 1000), s);
        }
        n -= 1000;
        s += 1000;
      }
    }

    static bool pythoncheckinterrupted() {
      if (!casadi::InterruptHandler::is_main_thread()) return false;
      return PyErr_CheckSignals();
    }

    std::string python_string_to_std_string(PyObject *str_py) {
#if SWIG_VERSION < 0x040200
      const char *str_char = SWIG_Python_str_AsChar(str_py);
      std::string str(str_char);
      SWIG_Python_str_DelForPy3(str_char);
#else
      PyObject *bytes = NULL;
      std::string str(SWIG_PyUnicode_AsUTF8AndSize(str_py, NULL, &bytes));
      Py_XDECREF(bytes);
#endif
      return str;
    }

    void handle_director_exception() {
	    std::string msg = "Exception in SWIG director ";
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt)) {
        PyErr_Clear();
        SWIG_PYTHON_THREAD_END_BLOCK;
        throw casadi::KeyboardInterruptException();
      }
      PyObject *ptype, *pvalue, *ptraceback;
      PyErr_Fetch(&ptype, &pvalue, &ptraceback);
      PyObject* msg_py = PyObject_Str(pvalue);
      msg = python_string_to_std_string(msg_py);
      Py_DECREF(msg_py);
      PyErr_Restore(ptype, pvalue, ptraceback);
      PyErr_Print();
      SWIG_PYTHON_THREAD_END_BLOCK;
      casadi_error(msg.c_str());
	  }
  }



#include <stdexcept>


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


#include <string>


#include <stddef.h>


#include <iostream>

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


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 = 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 <utility>


#include <map>


#include <algorithm>


#define SWIG_FILE_WITH_INIT


#define SWIG_Error_return(code, msg)  { std::cerr << "Error occured in CasADi SWIG interface code:" << std::endl << "  "<< msg << std::endl;SWIG_Error(code, msg); return 0; }


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) {
      Type *p;
      swig_type_info *descriptor = type_info<Type>();
      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      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, bool throw_error) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj, bool throw_error) {
      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 {
	// Uninitialized return value, no Type() constructor required.
	static Type *v_def = (Type*) malloc(sizeof(Type));
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	memset(v_def,0,sizeof(Type));
	return *v_def;
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj, bool throw_error) {
      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>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	return 0;
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj, bool te = false) {
    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
  }

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


#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
      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;
      }
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1
      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);
      }
    }
  }

  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, 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();
        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();
      if (ii > jj) {
        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 (jj < ii)
        jj = ii;
      if (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same 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; ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      if (jj > ii)
        jj = ii;
      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; ++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) {
      if (jj > ii) {
        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 {
      if (ii > jj) {
        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--;
        }
      }
    }
  }
}


#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 SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  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)
      : 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;
    }

    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 SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_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;
    }

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

  private:
    out_iterator begin;
    out_iterator end;
  };

  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_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
  }

}


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, true);
      } catch (std::exception& 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(bool set_err = true) 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)) {
	  if (set_err) {
	    char msg[1024];
	    sprintf(msg, "in sequence element %d", (int)i);
	    SWIG_Error(SWIG_RuntimeError, msg);
	  }
	  return false;
	}
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}



  namespace casadi {
    /* Check if Null or None */
    bool is_null(PyObject *p);

    /* Typemaps from CasADi types to types in the interfaced language:
     *
     * to_ptr: Converts a pointer in interfaced language to C++:
     *   Input: GUESTOBJECT pointer p
     *   Output: Pointer to pointer: At input, pointer to pointer to temporary
     *   The routine will either:
     *     - Do nothing, if 0
     *     - Change the pointer
     *     - Change the temporary object
     *   Returns true upon success, else false
     *
     * from_ptr: Converts result from CasADi to interfaced language
     */

    // Basic types
    bool to_ptr(PyObject *p, bool** m);
    PyObject* from_ptr(const bool *a);
    bool to_ptr(PyObject *p, casadi_int** m);
    PyObject* from_ptr(const casadi_int *a);
    bool to_ptr(PyObject *p, double** m);
    PyObject* from_ptr(const double *a);
    bool to_ptr(PyObject *p, std::string** m);
    PyObject* from_ptr(const std::string *a);

    // std::vector










    template<typename M> bool to_ptr(PyObject *p, std::vector<M>** m);
    template<typename M> bool to_ptr(PyObject *p, std::vector< std::vector<M> >** m);
    template<typename M> PyObject* from_ptr(const std::vector<M> *a);

    // std::pair




    template<typename M1, typename M2> bool to_ptr(PyObject *p, std::pair<M1, M2>** m);
    template<typename M1, typename M2> PyObject* from_ptr(const std::pair<M1, M2>* a);

    // std::map
    template<typename M> bool to_ptr(PyObject *p, std::map<std::string, M>** m);
    template<typename M> PyObject* from_ptr(const std::map<std::string, M> *a);

    // Slice
    bool to_ptr(PyObject *p, casadi::Slice** m);
    PyObject* from_ptr(const casadi::Slice *a);

    // Sparsity
    bool to_ptr(PyObject *p, casadi::Sparsity** m);
    PyObject* from_ptr(const casadi::Sparsity *a);

    // Matrix<>
    bool to_ptr(PyObject *p, casadi::DM** m);
    PyObject* from_ptr(const casadi::DM *a);
    bool to_ptr(PyObject *p, casadi::IM** m);
    PyObject* from_ptr(const casadi::IM *a);
    bool to_ptr(PyObject *p, casadi::SX** m);
    PyObject* from_ptr(const casadi::SX *a);

    // MX
    bool to_ptr(PyObject *p, casadi::MX** m);
    PyObject* from_ptr(const casadi::MX *a);

    // Function
    bool to_ptr(PyObject *p, casadi::Function** m);
    PyObject* from_ptr(const casadi::Function *a);

    // SXElem
    bool to_ptr(PyObject *p, casadi::SXElem** m);
    PyObject* from_ptr(const casadi::SXElem *a);

    // GenericType
    bool to_ptr(PyObject *p, casadi::GenericType** m);
    PyObject* from_ptr(const casadi::GenericType *a);

    // Same as to_ptr, but with pointer instead of pointer to pointer
    template<typename M> bool to_val(PyObject *p, M* m);

    // Check if conversion is possible
    template<typename M> bool can_convert(PyObject *p) { return to_ptr(p, static_cast<M**>(0));}

    // Same as the above, but with reference instead of pointer
    template<typename M> PyObject* from_ref(const M& m) { return from_ptr(&m);}

    // Specialization for std::vectors of booleans
    PyObject* from_ref(std::vector<bool>::const_reference m) {
      bool tmp = m;
      return from_ptr(&tmp);
    }

    // Same as the above, but with a temporary object
    template<typename M> PyObject* from_tmp(M m) { return from_ptr(&m);}








    PyObject* full(const DM& m, bool simplify=false) {

      PyObject *p = from_ptr(&m);
      PyObject *method_name = PyString_FromString("toarray");
      PyObject *cr = PyObject_CallMethodObjArgs(p, method_name, (simplify? Py_True: Py_False), 0);
      Py_DECREF(method_name);
      Py_DECREF(p);
      if (cr) return cr;
      return Py_None;








    }


    // Convert to a sparse matrix
    PyObject* sparse(const DM& m) {

      PyObject *p = from_ptr(&m);
      PyObject *cr = PyObject_CallMethod(p, (char*) "tocsc", 0);
      Py_DECREF(p);
      if (cr) return cr;
      return Py_None;










    }

    PyObject* full_or_sparse(const DM& m, bool simplify=false) {
      if (m.is_dense()) {
        return full(m, simplify);
      } else {
        PyObject* p = sparse(m);
        if (is_null(p)) return from_ptr(&m);
        return p;
      }
    }



    PyObject* get_Python_helper(const std::string& name) {
#if PY_VERSION_HEX < 0x03070000
      PyObject* module = PyImport_AddModule("casadi");
#else
      PyObject* c_name = PyString_FromString("casadi");
      PyObject* module = PyImport_GetModule(c_name);
      Py_DECREF(c_name);
#endif
      if (!module) {
        if (PyErr_Occurred()) {
          PyErr_Clear();
        }
      }
      PyObject* dict = PyModule_GetDict(module);
      return PyDict_GetItemString(dict, (char*) name.c_str());
    }

    template<class T>
    bool casadi_object_from_fun(PyObject *p, T** m, const std::string& fun, const std::function<bool(PyObject*, T**)> & conv) {
      PyObject* dm = get_Python_helper(fun);
      if (!dm) return false;
      PyObject *check_only = m? Py_False : Py_True;
      PyObject *cr = PyObject_CallFunctionObjArgs(dm, p, check_only, NULL);
      if (!cr) return false;
      bool ret;
      if (PyBool_Check(cr)) {
        ret = PyObject_IsTrue(cr);
      } else {
        ret = conv(cr, m);
      }
      Py_DECREF(cr);
      return ret;
    }

    bool SX_from_array_conv(PyObject *p, casadi::SX** m) {
      std::vector<SXElem> data;
      if (!to_val(PyTuple_GetItem(p, 2), &data)) return false;
      casadi_int nrow; to_val(PyTuple_GetItem(p, 0), &nrow);
      casadi_int ncol; to_val(PyTuple_GetItem(p, 1), &ncol);
      if (m) {
        **m = casadi::SX::zeros(nrow, ncol);
        casadi_densify(get_ptr(data), (**m).sparsity().T(), (**m).ptr(), true);
      }
      return true;
    }

    bool IM_from_array_conv(PyObject *p, casadi::IM** m) {
      if (!m) return true;
      std::vector<casadi_int> data;
      if (!to_val(PyTuple_GetItem(p, 2), &data)) return false;
      casadi_int nrow; to_val(PyTuple_GetItem(p, 0), &nrow);
      casadi_int ncol; to_val(PyTuple_GetItem(p, 1), &ncol);
      **m = IM::zeros(nrow, ncol);
      casadi_densify(get_ptr(data), (**m).sparsity().T(), (**m).ptr(), true);
      return true;
    }

    bool DM_from_array_conv(PyObject *p, casadi::DM** m) {
      if (!m) return true;
      std::vector<double> data;
      if (!to_val(PyTuple_GetItem(p, 2), &data)) return false;
      casadi_int nrow; to_val(PyTuple_GetItem(p, 0), &nrow);
      casadi_int ncol; to_val(PyTuple_GetItem(p, 1), &ncol);
      **m = DM::zeros(nrow, ncol);
      casadi_densify(get_ptr(data), (**m).sparsity().T(), (**m).ptr(), true);
      return true;
    }

    bool DM_from_csc_conv(PyObject *p, casadi::DM** m) {
      std::vector<double> data;
      std::vector<casadi_int> colind, row;
      if (!to_val(PyTuple_GetItem(p, 4), &data)) return false;
      if (!to_val(PyTuple_GetItem(p, 3), &row)) return false;
      if (!to_val(PyTuple_GetItem(p, 2), &colind)) return false;
      casadi_int nrow; to_val(PyTuple_GetItem(p, 0), &nrow);
      casadi_int ncol; to_val(PyTuple_GetItem(p, 1), &ncol);
      **m = casadi::Matrix<double>(casadi::Sparsity(nrow,ncol,colind,row), data, false);
      return true;
    }

    bool SX_from_array(PyObject *p, casadi::SX** m) {
      return casadi_object_from_fun<casadi::SX>(p, m, "SX_from_array", SX_from_array_conv);
    }

    bool IM_from_array(PyObject *p, casadi::IM** m) {
      return casadi_object_from_fun<casadi::IM>(p, m, "IM_from_array", IM_from_array_conv);
    }

    bool DM_from_array(PyObject *p, casadi::DM** m) {
      return casadi_object_from_fun<casadi::DM>(p, m, "DM_from_array", DM_from_array_conv);
    }

    bool DM_from_csc(PyObject *p, casadi::DM** m) {
      return casadi_object_from_fun<casadi::DM>(p, m, "DM_from_csc", DM_from_csc_conv);
    }

    bool is_scalar_np_array(PyObject *p) {
      if (PyObject_HasAttrString(p, "__array__")) {
        PyObject *cr = PyObject_GetAttrString(p, (char*) "size");
        if (cr) {
          casadi_int size;
          casadi_int res = to_val(cr, &size);
          Py_DECREF(cr);
          if (!res) return false;
          return size==1;
        } else {
          PyErr_Clear();
          return false;
        }
      }
      return false;
   }




  } // namespace CasADi
 

  namespace casadi {
    template<typename M> bool to_val(PyObject *p, M* m) {
      // Copy the pointer
      M *m2 = m;
      bool ret = to_ptr(p, m ? &m2 : 0);
      // If pointer changed, copy the object
      if (m!=m2) *m=*m2;
      return ret;
    }

    // Same as to_ptr, but with GenericType
    template<typename M> bool to_generic(PyObject *p, GenericType** m) {
      if (m) {
        // Temporary
        M tmp, *tmp_ptr=&tmp;
        bool ret = to_ptr(p, &tmp_ptr);
        if (!ret) return ret;
        **m = GenericType(*tmp_ptr);
        return ret;
      } else {
        return to_ptr(p, static_cast<M**>(0));
      }
    }

    // Check if casadi_int
    template<typename T> struct is_int {
      static inline bool check() {return false;}
    };

    template<> struct is_int<casadi_int> {
      static inline bool check() {return true;}
    };

    bool is_null(PyObject *p) {

      if (p == Py_None) return true;




      return false;
    }






































  } // namespace casadi
 


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


  namespace casadi {
    bool to_ptr(PyObject *p, bool** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Standard typemaps
      if (SWIG_IsOK(SWIG_AsVal_bool (p, m ? *m : 0))) return true;








      // No match
      return false;
    }

    PyObject * from_ptr(const bool *a) {

      return PyBool_FromLong(*a);





    }
  } // namespace casadi
 

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


  namespace casadi {
    bool to_ptr(PyObject *p, casadi_int** m) {
      // Treat Null
      if (is_null(p)) return false;

      // long long
      {
        long long tmp;
        if (SWIG_IsOK(SWIG_AsVal_long_SS_long (p, &tmp))) {
          if (m) **m = static_cast<casadi_int>(tmp);
          return true;
        }
      }


      if (is_scalar_np_array(p)) {
        PyObject *cr = PyObject_CallMethod(p, (char*) "item", 0);
        if (cr) {
          casadi_int res = to_ptr(cr, m);
          Py_DECREF(cr);
          if (!res) return false;
          return true;
        } else {
          PyErr_Clear();
          return false;
        }
      }


      bool tmp;
      if (to_val(p, m? &tmp : 0)) {
        if (m) **m = tmp;
        return true;
      }

      // No match
      return false;
    }

    PyObject * from_ptr(const casadi_int *a) {


      return PyLong_FromLongLong(*a);











    }
  } // namespace casadi
 

  namespace casadi {
    bool to_ptr(PyObject *p, double** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Standard typemaps
      if (SWIG_IsOK(SWIG_AsVal_double (p, m ? *m : 0))) return true;


      if (is_scalar_np_array(p)) {
        PyObject *cr = PyObject_CallMethod(p, (char*) "item", 0);
        if (cr) {
          casadi_int res = to_ptr(cr, m);
          Py_DECREF(cr);
          if (!res) return false;
          return true;
        } else {
          PyErr_Clear();
          return false;
        }
      }


      casadi_int tmp;
      if (to_val(p, m? &tmp: 0)) {
        if (m) **m = tmp;
        return true;
      }

      // No match
      return false;
    }

    PyObject * from_ptr(const double *a) {

      return PyFloat_FromDouble(*a);





    }
  } // namespace casadi
 

  namespace casadi {






























































































































































































    template<typename M> bool to_ptr(PyObject *p, std::vector<M>** m) {
      // Treat Null
      if (is_null(p)) return false;


      // Some built-in types are iterable
      if (PyDict_Check(p) || PyString_Check(p) || PySet_Check(p) || PyUnicode_Check(p)) return false;

      // Make sure shape is 1D, if defined.
      if (PyObject_HasAttrString(p, "shape")) {
        PyObject * shape = PyObject_GetAttrString(p, "shape");
        if(!PyTuple_Check(shape) || PyTuple_Size(shape)!=1) {
          Py_DECREF(shape);
          return false;
        }
      }

      // Iterator to the sequence
      PyObject *it = PyObject_GetIter(p);
      if (!it) {
        PyErr_Clear();
        return false;
      }

      // Allocate elements
      if (m) (**m).clear();

      // Temporary
      M tmp;

      PyObject *pe;
      // Iterate over sequence
      while ((pe=PyIter_Next(it))) {
        // Convert element
        M *m_i = m ? &tmp : 0;
        if (!to_ptr(pe, m_i ? &m_i : 0)) {
          // Failure
          Py_DECREF(pe);
          Py_DECREF(it);
          return false;
        }
        if (m) (**m).push_back(*m_i);
        Py_DECREF(pe);
      }
      Py_DECREF(it);
      return true;





      // No match
      return false;
    }



























    template<typename M> PyObject* from_ptr(const std::vector<M> *a) {

      // std::vector maps to Python list
      PyObject* ret = PyList_New(a->size());
      if (!ret) return 0;
      for (casadi_int k=0; k<a->size(); ++k) {
        PyObject* el = from_ref(a->at(k));
        if (!el) {
          Py_DECREF(ret);
          return 0;
        }
        PyList_SetItem(ret, k, el);
      }
      return ret;













    }
  } // namespace casadi


  namespace casadi {








































    template<typename M> bool to_ptr(PyObject *p, std::vector< std::vector<M> >** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Pass on to to_ptr(GUESTOBJECT *p, std::vector<M>** m)
      if (to_ptr< std::vector<M> >(p, m)) return true;





      return false;
    }

  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, Function** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Function already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__Function, 0))) {
        return true;
      }

      // No match
      return false;
    }

    PyObject* from_ptr(const Function *a) {
      return SWIG_NewPointerObj(new Function(*a), SWIGTYPE_p_casadi__Function, SWIG_POINTER_OWN);
    }
  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, GenericType** m) {

      if (p==Py_None) {
        if (m) **m=GenericType();
        return true;
      }


      // Treat Null
      if (is_null(p)) return false;

      // GenericType already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__GenericType, 0))) {
        return true;
      }

      // Try to convert to different types
      if (to_generic<casadi_int>(p, m)
          || to_generic<double>(p, m)
          || to_generic<std::string>(p, m)
          || to_generic<std::vector<casadi_int> >(p, m)
          || to_generic<std::vector<double> >(p, m)
          || to_generic<std::vector<bool> >(p, m)
          || to_generic<std::vector<std::string> >(p, m)
          || to_generic<std::vector<std::vector<std::string> > >(p, m)
          || to_generic<std::vector<std::vector<casadi_int> > >(p, m)
          || to_generic<std::vector<std::vector<double> > >(p, m)
          || to_generic<casadi::Function>(p, m)
          || to_generic<std::vector<casadi::Function> >(p, m)
          || to_generic<casadi::GenericType::Dict>(p, m)
          || to_generic<std::vector<casadi::GenericType::Dict> >(p, m)
          || to_generic<std::vector<std::vector<casadi::GenericType> > >(p, m)
          || to_generic<std::vector<casadi::GenericType> >(p, m)) {
        return true;
      }

      // Check if it can be converted to boolean (last as e.g. can be converted to boolean)
      if (to_generic<bool>(p, m)) return true;

      // No match
      return false;
    }

    PyObject * from_ptr(const GenericType *a) {
      switch (a->getType()) {
      case OT_BOOL: return from_tmp(a->as_bool());
      case OT_INT: return from_tmp(a->as_int());
      case OT_DOUBLE: return from_tmp(a->as_double());
      case OT_STRING: return from_tmp(a->as_string());
      case OT_INTVECTOR: return from_tmp(a->as_int_vector());
      case OT_INTVECTORVECTOR: return from_tmp(a->as_int_vector_vector());
      case OT_BOOLVECTOR: return from_tmp(a->as_bool_vector());
      case OT_DOUBLEVECTOR: return from_tmp(a->as_double_vector());
      case OT_DOUBLEVECTORVECTOR: return from_tmp(a->as_double_vector_vector());
      case OT_STRINGVECTOR: return from_tmp(a->as_string_vector());
      case OT_STRINGVECTORVECTOR: return from_tmp(a->as_string_vector_vector());
      case OT_DICT: return from_tmp(a->as_dict());
      case OT_DICTVECTOR: return from_tmp(a->as_dict_vector());
      case OT_VECTORVECTOR: return from_tmp(a->as_vector_vector());
      case OT_VECTOR: return from_tmp(a->as_vector());
      case OT_FUNCTION: return from_tmp(a->as_function());
      case OT_FUNCTIONVECTOR: return from_tmp(a->as_function_vector());

      case OT_NULL:
      case OT_VOIDPTR:
        return Py_None;





      default: return 0;
      }
    }
  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, std::string** m) {
      // Treat Null
      if (is_null(p)) return false;

      // String already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_std__string, 0))) {
        return true;
      }


      if (PyString_Check(p) || PyUnicode_Check(p)) {
        if (m) {
          (*m)->clear();
          (*m)->append(python_string_to_std_string(p));
        }
        return true;
      }














      // No match
      return false;
    }

    PyObject* from_ptr(const std::string *a) {

      return PyString_FromString(a->c_str());





    }
  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, Slice** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Slice already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__Slice, 0))) {
        return true;
      }



      // Python casadi_int
      if (PyInt_Check(p)) {
        if (m) {
          (**m).start = PyInt_AsLong(p);
          (**m).stop = (**m).start+1;
          if ((**m).stop==0) (**m).stop = std::numeric_limits<casadi_int>::max();
        }
        return true;
      }
      // Python slice
      if (PySlice_Check(p)) {
        PySliceObject *r = (PySliceObject*)(p);
        if (m) {
          (**m).start = (r->start == Py_None || PyNumber_AsSsize_t(r->start, NULL) <= std::numeric_limits<int>::min())
            ? std::numeric_limits<casadi_int>::min() : PyInt_AsLong(r->start);
          (**m).stop  = (r->stop ==Py_None || PyNumber_AsSsize_t(r->stop, NULL)>= std::numeric_limits<int>::max())
            ? std::numeric_limits<casadi_int>::max() : PyInt_AsLong(r->stop);
          if(r->step !=Py_None) (**m).step  = PyInt_AsLong(r->step);
        }
        return true;
      }


      // No match
      return false;
    }

    PyObject* from_ptr(const Slice *a) {
      return SWIG_NewPointerObj(new Slice(*a), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_OWN);
    }

  } // namespace casadi


  namespace casadi {
    template<typename M> bool to_ptr(PyObject *p, std::map<std::string, M>** m) {

      if (PyDict_Check(p)) {
        PyObject *key, *value;
        Py_ssize_t pos = 0;
        while (PyDict_Next(p, &pos, &key, &value)) {
          if (!(PyString_Check(key) || PyUnicode_Check(key))) return false;
          if (m) {
            M *v=&(**m)[python_string_to_std_string(key)], *v2=v;
            if (!casadi::to_ptr(value, &v)) return false;
            if (v!=v2) *v2=*v; // if only pointer changed
          } else {
            if (!casadi::to_ptr(value, static_cast<M**>(0))) return false;
          }
        }
        return true;
      }
















      return false;
    }

    template<typename M> PyObject* from_ptr(const std::map<std::string, M> *a) {

      PyObject *p = PyDict_New();
      for (typename std::map<std::string, M>::const_iterator it=a->begin(); it!=a->end(); ++it) {
        PyObject * e = from_ptr(&it->second);
        if (!e) {
          Py_DECREF(p);
          return 0;
        }
        PyDict_SetItemString(p, it->first.c_str(), e);
        Py_DECREF(e);
      }
      return p;























    }
  } // namespace casadi


  namespace casadi {





















    template<typename M1, typename M2> bool to_ptr(PyObject *p, std::pair<M1, M2>** m) {

      if (PyTuple_Check(p) && PyTuple_Size(p)==2) {
        PyObject *p_first = PyTuple_GetItem(p, 0);
        PyObject *p_second = PyTuple_GetItem(p, 1);
	return to_val(p_first, m ? &(**m).first : 0)
	  && to_val(p_second, m ? &(**m).second : 0);
      }









      // No match
      return false;
    }












    template<typename M1, typename M2> PyObject* from_ptr(const std::pair<M1, M2>* a) {

      PyObject* ret = PyTuple_New(2);
      PyTuple_SetItem(ret, 0, from_ref(a->first));
      PyTuple_SetItem(ret, 1, from_ref(a->second));
      return ret;









    }
  } // namespace casadi
 

  namespace casadi {
    bool to_ptr(PyObject *p, SX** m) {
      // Treat Null
      if (is_null(p)) return false;

      // SX already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0))) {
        return true;
      }

      // Try first converting to a temporary DM
      {
        DM tmp;
        if(to_val(p, m? &tmp: 0)) {
          if (m) **m = tmp;
          return true;
        }
      }


      // Numpy arrays will be cast to dense SX
      if (SX_from_array(p, m)) return true;
      // Object has __SX__ method
      if (PyObject_HasAttrString(p,"__SX__")) {
        PyObject *cr = PyObject_CallMethod(p, (char*) "__SX__", 0);
        if (!cr) return false;
        casadi_int flag = to_ptr(cr, m);
        Py_DECREF(cr);
        return flag;
      }


      // No match
      return false;
    }

    PyObject* from_ptr(const SX *a) {
      return SWIG_NewPointerObj(new SX(*a), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_OWN);
    }
  } // namespace casadi
 

  namespace casadi {
    bool to_ptr(PyObject *p, SXElem** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Try first converting to a temporary SX
      {
        SX tmp, *mt=&tmp;
        if(casadi::to_ptr(p, m ? &mt : 0)) {
          if (m && !mt->is_scalar()) return false;
          if (m) **m = mt->scalar();
          return true;
        }
      }

      // No match
      return false;
    }

    PyObject* from_ptr(const SXElem *a) {
      return from_ref(SX(*a));
    }
  } // namespace casadi
 

  namespace casadi {
    bool to_ptr(PyObject *p, MX** m) {
      // Treat Null
      if (is_null(p)) return false;

      // MX already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__MX, 0))) {
        return true;
      }

      // Try first converting to a temporary DM
      {
        DM tmp;
        if(to_val(p, m ? &tmp : 0)) {
          if (m) **m = tmp;
          return true;
        }
      }


      if (PyObject_HasAttrString(p,"__MX__")) {
        PyObject *cr = PyObject_CallMethod(p, (char*) "__MX__", 0);
        if (!cr) return false;
        casadi_int flag = to_ptr(cr, m);
        Py_DECREF(cr);
        return flag;
      }


      // No match
      return false;
    }

    PyObject* from_ptr(const MX *a) {
      return SWIG_NewPointerObj(new MX(*a), SWIGTYPE_p_casadi__MX, SWIG_POINTER_OWN);
    }
  } // namespace casadi
 

  namespace casadi {

    /** Check PyObjects by class name */
    bool PyObjectHasClassName(PyObject* p, const char * name) {
      PyObject * classo = PyObject_GetAttrString( p, "__class__");
      PyObject * classname = PyObject_GetAttrString( classo, "__name__");

      bool ret = python_string_to_std_string(classname) == name;
      Py_DECREF(classo);Py_DECREF(classname);
      return ret;
    }


    bool to_ptr(PyObject *p, DM** m) {
      // Treat Null
      if (is_null(p)) return false;

      // DM already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__MatrixT_double_t, 0))) {
        return true;
      }

      // Object is a sparsity pattern
      {
        Sparsity *m2;
        if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(&m2),
                                      SWIGTYPE_p_casadi__Sparsity, 0))) {
          if (m) **m=DM::ones(*m2);
          return true;
        }
      }

      // Double scalar
      {
        double tmp;
        if (to_val(p, m? &tmp: 0)) {
          if (m) **m=tmp;
          return true;
        }
      }


      // Object has __DM__ method
      if (PyObject_HasAttrString(p,"__DM__")) {
        char name[] = "__DM__";
        PyObject *cr = PyObject_CallMethod(p, name, 0);
        if (!cr) return false;
        casadi_int result = to_val(cr, m ? *m : 0);
        Py_DECREF(cr);
        return result;
      }

      if (DM_from_array(p, m)) return true;

      if (DM_from_csc(p,m)) return true;

      {
        std::vector <double> t;
        casadi_int res = to_val(p, &t);
        if (t.size()>0) {
          if (m) **m = casadi::Matrix<double>(t);
        } else {
          if (m) **m = casadi::Matrix<double>(0,0);
        }
        return res;
      }













      // No match
      return false;
    }

    PyObject* from_ptr(const DM *a) {
      return SWIG_NewPointerObj(new DM(*a), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_OWN);
    }
  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, Sparsity** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Sparsity already?
      if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(m),
                                    SWIGTYPE_p_casadi__Sparsity, 0))) {
        return true;
      }

      // No match
      return false;
    }

    PyObject* from_ptr(const Sparsity *a) {
      return SWIG_NewPointerObj(new Sparsity(*a), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_OWN);
    }
  } // namespace casadi


  namespace casadi {
    bool to_ptr(PyObject *p, IM** m) {
      // Treat Null
      if (is_null(p)) return false;

      // Object is a sparsity pattern
      {
        Sparsity *m2;
        if (SWIG_IsOK(SWIG_ConvertPtr(p, reinterpret_cast<void**>(&m2),
                                      SWIGTYPE_p_casadi__Sparsity, 0))) {
          if (m) **m=IM::ones(*m2);
          return true;
        }
      }

      // First convert to integer
      {
        casadi_int tmp;
        if (to_val(p, m? &tmp: 0)) {
          if (m) **m=tmp;
          return true;
        }
      }


      // Numpy arrays will be cast to dense Matrix<casadi_int>
      if (IM_from_array(p, m)) return true;

      if (PyObject_HasAttrString(p,"__IM__")) {
        PyObject *cr = PyObject_CallMethod(p, (char*) "__IM__", 0);
        if (!cr) return false;
        casadi_int result = to_val(cr, m ? *m : 0);
        Py_DECREF(cr);
        return result;
      }

      {
        std::vector <casadi_int> t;
        if (to_val(p, &t)) {
          if (m) **m = casadi::Matrix<casadi_int>(t);
          return true;
        }
      }






























      // Convert from DM
      {
        DM tmp;
        if (to_val(p, m? &tmp: 0)) {
          // Check integrality
          for (double d : tmp.nonzeros()) {
            if (d!=casadi_int(d)) return false;
          }
          // Convert
          if (m) {
            **m = casadi::Matrix<double>(tmp);
          }
          return true;
        }
      }

      // No match
      return false;
    }
    PyObject* from_ptr(const IM *a) {
      DM tmp(*a);
      return from_ref(tmp);
    }

  } // namespace casadi
 
 

SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< 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 void casadi_Matrix_Sl_double_Sg__assign(casadi::Matrix< double > *self,casadi::Matrix< double > const &rhs){ (*self)=rhs; }
SWIGINTERN PyObject *casadi_Matrix_Sl_double_Sg__full(casadi::Matrix< double > const *self){
      return full(*self);
    }
SWIGINTERN PyObject *casadi_Matrix_Sl_double_Sg__sparse(casadi::Matrix< double > const *self){
      return sparse(*self);
    }

  namespace casadi {
    /*@SWIG:/local/swig/python/../casadi.i,3084,SPARSITY_INTERFACE_ALL@*/
/*@SWIG:/local/swig/python/../casadi.i,3101,SPARSITY_INTERFACE_FUN@*/
    /*@SWIG:/local/swig/python/../casadi.i,2958,SPARSITY_INTERFACE_FUN_BASE@*/


 inline Sparsity casadi_horzcat(const std::vector< Sparsity > &v) {
  return horzcat(v);
 }
 inline Sparsity casadi_vertcat(const std::vector< Sparsity > &v) {
 return vertcat(v);
 }
 inline std::vector< Sparsity >
 casadi_horzsplit(const Sparsity& v, const std::vector<casadi_int>& offset) {
 return horzsplit(v, offset);
 }
 inline std::vector< Sparsity > casadi_horzsplit(const Sparsity& v, casadi_int incr=1) {
 return horzsplit(v, incr);
 }
 inline std::vector< Sparsity > casadi_horzsplit_n(const Sparsity& v, casadi_int n) {
 return horzsplit_n(v, n);
 }
 inline std::vector< Sparsity >
 casadi_vertsplit(const Sparsity& v, const std::vector<casadi_int>& offset) {
 return vertsplit(v, offset);
 }
 inline std::vector<casadi_int >
 casadi_offset(const std::vector< Sparsity > &v, bool vert=true) {
 return offset(v, vert);
 }
 inline std::vector< Sparsity >
 casadi_vertsplit(const Sparsity& v, casadi_int incr=1) {
 return vertsplit(v, incr);
 }
 inline std::vector< Sparsity >
 casadi_vertsplit_n(const Sparsity& v, casadi_int n) {
 return vertsplit_n(v, n);
 }
 inline Sparsity casadi_blockcat(const Sparsity& A, const Sparsity& B, const Sparsity& C, const Sparsity& D) {
 return vertcat(horzcat(A, B), horzcat(C, D));
 }
 inline std::vector< std::vector< Sparsity > >
 casadi_blocksplit(const Sparsity& x, const std::vector<casadi_int>& vert_offset,
 const std::vector<casadi_int>& horz_offset) {
 return blocksplit(x, vert_offset, horz_offset);
 }
 inline std::vector< std::vector< Sparsity > >
 casadi_blocksplit(const Sparsity& x, casadi_int vert_incr=1, casadi_int horz_incr=1) {
 return blocksplit(x, vert_incr, horz_incr);
 }
 inline Sparsity casadi_diagcat(const std::vector< Sparsity > &A) {
 return diagcat(A);
 }
 inline std::vector< Sparsity >
 casadi_diagsplit(const Sparsity& x, const std::vector<casadi_int>& output_offset1,
 const std::vector<casadi_int>& output_offset2) {
 return diagsplit(x, output_offset1, output_offset2);
 }
 inline std::vector< Sparsity >
 casadi_diagsplit(const Sparsity& x, const std::vector<casadi_int>& output_offset) {
 return diagsplit(x, output_offset);
 }
 inline std::vector< Sparsity > casadi_diagsplit(const Sparsity& x, casadi_int incr=1) {
 return diagsplit(x, incr);
 }
 inline std::vector< Sparsity >
 casadi_diagsplit(const Sparsity& x, casadi_int incr1, casadi_int incr2) {
 return diagsplit(x, incr1, incr2);
 }
 inline Sparsity casadi_veccat(const std::vector< Sparsity >& x) {
 return veccat(x);
 }
 inline Sparsity casadi_mtimes(const Sparsity& x, const Sparsity& y) {
 return mtimes(x, y);
 }
 inline Sparsity casadi_mtimes(const std::vector< Sparsity > &args) {
 return mtimes(args);
 }
 inline Sparsity casadi_mac(const Sparsity& X, const Sparsity& Y, const Sparsity& Z) {
 return mac(X, Y, Z);
 }
 inline Sparsity casadi_transpose(const Sparsity& X) {
 return X.T();
 }
 inline Sparsity casadi_vec(const Sparsity& a) {
 return vec(a);
 }
 inline Sparsity casadi_reshape(const Sparsity& a, casadi_int nrow, casadi_int ncol) {
 return reshape(a, nrow, ncol);
 }
 inline Sparsity casadi_reshape(const Sparsity& a, std::pair<casadi_int, casadi_int> rc) {
 return reshape(a, rc.first, rc.second);
 }
 inline Sparsity casadi_reshape(const Sparsity& a, const Sparsity& sp) {
 return reshape(a, sp);
 }
 inline Sparsity casadi_sparsity_cast(const Sparsity& a, const Sparsity& sp) {
 return sparsity_cast(a, sp);
 }
 inline casadi_int casadi_sprank(const Sparsity& A) {
 return sprank(A);
 }
 inline casadi_int casadi_norm_0_mul(const Sparsity& x, const Sparsity& y) {
 return norm_0_mul(x, y);
 }
 inline Sparsity casadi_triu(const Sparsity& a, bool includeDiagonal=true) {
 return triu(a, includeDiagonal);
 }
 inline Sparsity casadi_tril(const Sparsity& a, bool includeDiagonal=true) {
 return tril(a, includeDiagonal);
 }
 inline Sparsity casadi_kron(const Sparsity& a, const Sparsity& b) {
 return kron(a, b);
 }
 inline Sparsity casadi_repmat(const Sparsity& A, casadi_int n, casadi_int m=1) {
 return repmat(A, n, m);
 }
 inline Sparsity casadi_repmat(const Sparsity& A, const std::pair<casadi_int, casadi_int>& rc) {
 return repmat(A, rc.first, rc.second);
 }
 inline Sparsity casadi_sum2(const Sparsity& x) {
 return sum2(x);
 }
 inline Sparsity casadi_sum1(const Sparsity& x) {
 return sum1(x);
 }

/*@SWIG@*/
  /*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3101,SPARSITY_INTERFACE_FUN@*/
    /*@SWIG:/local/swig/python/../casadi.i,2958,SPARSITY_INTERFACE_FUN_BASE@*/


 inline MX casadi_horzcat(const std::vector< MX > &v) {
  return horzcat(v);
 }
 inline MX casadi_vertcat(const std::vector< MX > &v) {
 return vertcat(v);
 }
 inline std::vector< MX >
 casadi_horzsplit(const MX& v, const std::vector<casadi_int>& offset) {
 return horzsplit(v, offset);
 }
 inline std::vector< MX > casadi_horzsplit(const MX& v, casadi_int incr=1) {
 return horzsplit(v, incr);
 }
 inline std::vector< MX > casadi_horzsplit_n(const MX& v, casadi_int n) {
 return horzsplit_n(v, n);
 }
 inline std::vector< MX >
 casadi_vertsplit(const MX& v, const std::vector<casadi_int>& offset) {
 return vertsplit(v, offset);
 }
 inline std::vector<casadi_int >
 casadi_offset(const std::vector< MX > &v, bool vert=true) {
 return offset(v, vert);
 }
 inline std::vector< MX >
 casadi_vertsplit(const MX& v, casadi_int incr=1) {
 return vertsplit(v, incr);
 }
 inline std::vector< MX >
 casadi_vertsplit_n(const MX& v, casadi_int n) {
 return vertsplit_n(v, n);
 }
 inline MX casadi_blockcat(const MX& A, const MX& B, const MX& C, const MX& D) {
 return vertcat(horzcat(A, B), horzcat(C, D));
 }
 inline std::vector< std::vector< MX > >
 casadi_blocksplit(const MX& x, const std::vector<casadi_int>& vert_offset,
 const std::vector<casadi_int>& horz_offset) {
 return blocksplit(x, vert_offset, horz_offset);
 }
 inline std::vector< std::vector< MX > >
 casadi_blocksplit(const MX& x, casadi_int vert_incr=1, casadi_int horz_incr=1) {
 return blocksplit(x, vert_incr, horz_incr);
 }
 inline MX casadi_diagcat(const std::vector< MX > &A) {
 return diagcat(A);
 }
 inline std::vector< MX >
 casadi_diagsplit(const MX& x, const std::vector<casadi_int>& output_offset1,
 const std::vector<casadi_int>& output_offset2) {
 return diagsplit(x, output_offset1, output_offset2);
 }
 inline std::vector< MX >
 casadi_diagsplit(const MX& x, const std::vector<casadi_int>& output_offset) {
 return diagsplit(x, output_offset);
 }
 inline std::vector< MX > casadi_diagsplit(const MX& x, casadi_int incr=1) {
 return diagsplit(x, incr);
 }
 inline std::vector< MX >
 casadi_diagsplit(const MX& x, casadi_int incr1, casadi_int incr2) {
 return diagsplit(x, incr1, incr2);
 }
 inline MX casadi_veccat(const std::vector< MX >& x) {
 return veccat(x);
 }
 inline MX casadi_mtimes(const MX& x, const MX& y) {
 return mtimes(x, y);
 }
 inline MX casadi_mtimes(const std::vector< MX > &args) {
 return mtimes(args);
 }
 inline MX casadi_mac(const MX& X, const MX& Y, const MX& Z) {
 return mac(X, Y, Z);
 }
 inline MX casadi_transpose(const MX& X) {
 return X.T();
 }
 inline MX casadi_vec(const MX& a) {
 return vec(a);
 }
 inline MX casadi_reshape(const MX& a, casadi_int nrow, casadi_int ncol) {
 return reshape(a, nrow, ncol);
 }
 inline MX casadi_reshape(const MX& a, std::pair<casadi_int, casadi_int> rc) {
 return reshape(a, rc.first, rc.second);
 }
 inline MX casadi_reshape(const MX& a, const Sparsity& sp) {
 return reshape(a, sp);
 }
 inline MX casadi_sparsity_cast(const MX& a, const Sparsity& sp) {
 return sparsity_cast(a, sp);
 }
 inline casadi_int casadi_sprank(const MX& A) {
 return sprank(A);
 }
 inline casadi_int casadi_norm_0_mul(const MX& x, const MX& y) {
 return norm_0_mul(x, y);
 }
 inline MX casadi_triu(const MX& a, bool includeDiagonal=true) {
 return triu(a, includeDiagonal);
 }
 inline MX casadi_tril(const MX& a, bool includeDiagonal=true) {
 return tril(a, includeDiagonal);
 }
 inline MX casadi_kron(const MX& a, const MX& b) {
 return kron(a, b);
 }
 inline MX casadi_repmat(const MX& A, casadi_int n, casadi_int m=1) {
 return repmat(A, n, m);
 }
 inline MX casadi_repmat(const MX& A, const std::pair<casadi_int, casadi_int>& rc) {
 return repmat(A, rc.first, rc.second);
 }
 inline MX casadi_sum2(const MX& x) {
 return sum2(x);
 }
 inline MX casadi_sum1(const MX& x) {
 return sum1(x);
 }

/*@SWIG@*/
  /*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3101,SPARSITY_INTERFACE_FUN@*/
    /*@SWIG:/local/swig/python/../casadi.i,2958,SPARSITY_INTERFACE_FUN_BASE@*/


 inline Matrix<double> casadi_horzcat(const std::vector< Matrix<double> > &v) {
  return horzcat(v);
 }
 inline Matrix<double> casadi_vertcat(const std::vector< Matrix<double> > &v) {
 return vertcat(v);
 }
 inline std::vector< Matrix<double> >
 casadi_horzsplit(const Matrix<double>& v, const std::vector<casadi_int>& offset) {
 return horzsplit(v, offset);
 }
 inline std::vector< Matrix<double> > casadi_horzsplit(const Matrix<double>& v, casadi_int incr=1) {
 return horzsplit(v, incr);
 }
 inline std::vector< Matrix<double> > casadi_horzsplit_n(const Matrix<double>& v, casadi_int n) {
 return horzsplit_n(v, n);
 }
 inline std::vector< Matrix<double> >
 casadi_vertsplit(const Matrix<double>& v, const std::vector<casadi_int>& offset) {
 return vertsplit(v, offset);
 }
 inline std::vector<casadi_int >
 casadi_offset(const std::vector< Matrix<double> > &v, bool vert=true) {
 return offset(v, vert);
 }
 inline std::vector< Matrix<double> >
 casadi_vertsplit(const Matrix<double>& v, casadi_int incr=1) {
 return vertsplit(v, incr);
 }
 inline std::vector< Matrix<double> >
 casadi_vertsplit_n(const Matrix<double>& v, casadi_int n) {
 return vertsplit_n(v, n);
 }
 inline Matrix<double> casadi_blockcat(const Matrix<double>& A, const Matrix<double>& B, const Matrix<double>& C, const Matrix<double>& D) {
 return vertcat(horzcat(A, B), horzcat(C, D));
 }
 inline std::vector< std::vector< Matrix<double> > >
 casadi_blocksplit(const Matrix<double>& x, const std::vector<casadi_int>& vert_offset,
 const std::vector<casadi_int>& horz_offset) {
 return blocksplit(x, vert_offset, horz_offset);
 }
 inline std::vector< std::vector< Matrix<double> > >
 casadi_blocksplit(const Matrix<double>& x, casadi_int vert_incr=1, casadi_int horz_incr=1) {
 return blocksplit(x, vert_incr, horz_incr);
 }
 inline Matrix<double> casadi_diagcat(const std::vector< Matrix<double> > &A) {
 return diagcat(A);
 }
 inline std::vector< Matrix<double> >
 casadi_diagsplit(const Matrix<double>& x, const std::vector<casadi_int>& output_offset1,
 const std::vector<casadi_int>& output_offset2) {
 return diagsplit(x, output_offset1, output_offset2);
 }
 inline std::vector< Matrix<double> >
 casadi_diagsplit(const Matrix<double>& x, const std::vector<casadi_int>& output_offset) {
 return diagsplit(x, output_offset);
 }
 inline std::vector< Matrix<double> > casadi_diagsplit(const Matrix<double>& x, casadi_int incr=1) {
 return diagsplit(x, incr);
 }
 inline std::vector< Matrix<double> >
 casadi_diagsplit(const Matrix<double>& x, casadi_int incr1, casadi_int incr2) {
 return diagsplit(x, incr1, incr2);
 }
 inline Matrix<double> casadi_veccat(const std::vector< Matrix<double> >& x) {
 return veccat(x);
 }
 inline Matrix<double> casadi_mtimes(const Matrix<double>& x, const Matrix<double>& y) {
 return mtimes(x, y);
 }
 inline Matrix<double> casadi_mtimes(const std::vector< Matrix<double> > &args) {
 return mtimes(args);
 }
 inline Matrix<double> casadi_mac(const Matrix<double>& X, const Matrix<double>& Y, const Matrix<double>& Z) {
 return mac(X, Y, Z);
 }
 inline Matrix<double> casadi_transpose(const Matrix<double>& X) {
 return X.T();
 }
 inline Matrix<double> casadi_vec(const Matrix<double>& a) {
 return vec(a);
 }
 inline Matrix<double> casadi_reshape(const Matrix<double>& a, casadi_int nrow, casadi_int ncol) {
 return reshape(a, nrow, ncol);
 }
 inline Matrix<double> casadi_reshape(const Matrix<double>& a, std::pair<casadi_int, casadi_int> rc) {
 return reshape(a, rc.first, rc.second);
 }
 inline Matrix<double> casadi_reshape(const Matrix<double>& a, const Sparsity& sp) {
 return reshape(a, sp);
 }
 inline Matrix<double> casadi_sparsity_cast(const Matrix<double>& a, const Sparsity& sp) {
 return sparsity_cast(a, sp);
 }
 inline casadi_int casadi_sprank(const Matrix<double>& A) {
 return sprank(A);
 }
 inline casadi_int casadi_norm_0_mul(const Matrix<double>& x, const Matrix<double>& y) {
 return norm_0_mul(x, y);
 }
 inline Matrix<double> casadi_triu(const Matrix<double>& a, bool includeDiagonal=true) {
 return triu(a, includeDiagonal);
 }
 inline Matrix<double> casadi_tril(const Matrix<double>& a, bool includeDiagonal=true) {
 return tril(a, includeDiagonal);
 }
 inline Matrix<double> casadi_kron(const Matrix<double>& a, const Matrix<double>& b) {
 return kron(a, b);
 }
 inline Matrix<double> casadi_repmat(const Matrix<double>& A, casadi_int n, casadi_int m=1) {
 return repmat(A, n, m);
 }
 inline Matrix<double> casadi_repmat(const Matrix<double>& A, const std::pair<casadi_int, casadi_int>& rc) {
 return repmat(A, rc.first, rc.second);
 }
 inline Matrix<double> casadi_sum2(const Matrix<double>& x) {
 return sum2(x);
 }
 inline Matrix<double> casadi_sum1(const Matrix<double>& x) {
 return sum1(x);
 }

/*@SWIG@*/
  /*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3101,SPARSITY_INTERFACE_FUN@*/
    /*@SWIG:/local/swig/python/../casadi.i,2958,SPARSITY_INTERFACE_FUN_BASE@*/


 inline Matrix<SXElem> casadi_horzcat(const std::vector< Matrix<SXElem> > &v) {
  return horzcat(v);
 }
 inline Matrix<SXElem> casadi_vertcat(const std::vector< Matrix<SXElem> > &v) {
 return vertcat(v);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_horzsplit(const Matrix<SXElem>& v, const std::vector<casadi_int>& offset) {
 return horzsplit(v, offset);
 }
 inline std::vector< Matrix<SXElem> > casadi_horzsplit(const Matrix<SXElem>& v, casadi_int incr=1) {
 return horzsplit(v, incr);
 }
 inline std::vector< Matrix<SXElem> > casadi_horzsplit_n(const Matrix<SXElem>& v, casadi_int n) {
 return horzsplit_n(v, n);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_vertsplit(const Matrix<SXElem>& v, const std::vector<casadi_int>& offset) {
 return vertsplit(v, offset);
 }
 inline std::vector<casadi_int >
 casadi_offset(const std::vector< Matrix<SXElem> > &v, bool vert=true) {
 return offset(v, vert);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_vertsplit(const Matrix<SXElem>& v, casadi_int incr=1) {
 return vertsplit(v, incr);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_vertsplit_n(const Matrix<SXElem>& v, casadi_int n) {
 return vertsplit_n(v, n);
 }
 inline Matrix<SXElem> casadi_blockcat(const Matrix<SXElem>& A, const Matrix<SXElem>& B, const Matrix<SXElem>& C, const Matrix<SXElem>& D) {
 return vertcat(horzcat(A, B), horzcat(C, D));
 }
 inline std::vector< std::vector< Matrix<SXElem> > >
 casadi_blocksplit(const Matrix<SXElem>& x, const std::vector<casadi_int>& vert_offset,
 const std::vector<casadi_int>& horz_offset) {
 return blocksplit(x, vert_offset, horz_offset);
 }
 inline std::vector< std::vector< Matrix<SXElem> > >
 casadi_blocksplit(const Matrix<SXElem>& x, casadi_int vert_incr=1, casadi_int horz_incr=1) {
 return blocksplit(x, vert_incr, horz_incr);
 }
 inline Matrix<SXElem> casadi_diagcat(const std::vector< Matrix<SXElem> > &A) {
 return diagcat(A);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_diagsplit(const Matrix<SXElem>& x, const std::vector<casadi_int>& output_offset1,
 const std::vector<casadi_int>& output_offset2) {
 return diagsplit(x, output_offset1, output_offset2);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_diagsplit(const Matrix<SXElem>& x, const std::vector<casadi_int>& output_offset) {
 return diagsplit(x, output_offset);
 }
 inline std::vector< Matrix<SXElem> > casadi_diagsplit(const Matrix<SXElem>& x, casadi_int incr=1) {
 return diagsplit(x, incr);
 }
 inline std::vector< Matrix<SXElem> >
 casadi_diagsplit(const Matrix<SXElem>& x, casadi_int incr1, casadi_int incr2) {
 return diagsplit(x, incr1, incr2);
 }
 inline Matrix<SXElem> casadi_veccat(const std::vector< Matrix<SXElem> >& x) {
 return veccat(x);
 }
 inline Matrix<SXElem> casadi_mtimes(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
 return mtimes(x, y);
 }
 inline Matrix<SXElem> casadi_mtimes(const std::vector< Matrix<SXElem> > &args) {
 return mtimes(args);
 }
 inline Matrix<SXElem> casadi_mac(const Matrix<SXElem>& X, const Matrix<SXElem>& Y, const Matrix<SXElem>& Z) {
 return mac(X, Y, Z);
 }
 inline Matrix<SXElem> casadi_transpose(const Matrix<SXElem>& X) {
 return X.T();
 }
 inline Matrix<SXElem> casadi_vec(const Matrix<SXElem>& a) {
 return vec(a);
 }
 inline Matrix<SXElem> casadi_reshape(const Matrix<SXElem>& a, casadi_int nrow, casadi_int ncol) {
 return reshape(a, nrow, ncol);
 }
 inline Matrix<SXElem> casadi_reshape(const Matrix<SXElem>& a, std::pair<casadi_int, casadi_int> rc) {
 return reshape(a, rc.first, rc.second);
 }
 inline Matrix<SXElem> casadi_reshape(const Matrix<SXElem>& a, const Sparsity& sp) {
 return reshape(a, sp);
 }
 inline Matrix<SXElem> casadi_sparsity_cast(const Matrix<SXElem>& a, const Sparsity& sp) {
 return sparsity_cast(a, sp);
 }
 inline casadi_int casadi_sprank(const Matrix<SXElem>& A) {
 return sprank(A);
 }
 inline casadi_int casadi_norm_0_mul(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
 return norm_0_mul(x, y);
 }
 inline Matrix<SXElem> casadi_triu(const Matrix<SXElem>& a, bool includeDiagonal=true) {
 return triu(a, includeDiagonal);
 }
 inline Matrix<SXElem> casadi_tril(const Matrix<SXElem>& a, bool includeDiagonal=true) {
 return tril(a, includeDiagonal);
 }
 inline Matrix<SXElem> casadi_kron(const Matrix<SXElem>& a, const Matrix<SXElem>& b) {
 return kron(a, b);
 }
 inline Matrix<SXElem> casadi_repmat(const Matrix<SXElem>& A, casadi_int n, casadi_int m=1) {
 return repmat(A, n, m);
 }
 inline Matrix<SXElem> casadi_repmat(const Matrix<SXElem>& A, const std::pair<casadi_int, casadi_int>& rc) {
 return repmat(A, rc.first, rc.second);
 }
 inline Matrix<SXElem> casadi_sum2(const Matrix<SXElem>& x) {
 return sum2(x);
 }
 inline Matrix<SXElem> casadi_sum1(const Matrix<SXElem>& x) {
 return sum1(x);
 }

/*@SWIG@*/
  /*@SWIG@*/
/*@SWIG@*/
    /*@SWIG:/local/swig/python/../casadi.i,3495,GENERIC_EXPRESSION_ALL@*/
/*@SWIG:/local/swig/python/../casadi.i,3440,GENERIC_EXPRESSION_FUN@*/

inline MX casadi_plus(const MX& x, const MX& y) { return x+y; }
inline MX casadi_minus(const MX& x, const MX& y) { return x-y; }
inline MX casadi_times(const MX& x, const MX& y) { return x*y; }
inline MX casadi_rdivide(const MX& x, const MX& y) { return x/y; }
inline MX casadi_ldivide(const MX& x, const MX& y) { return y/x; }
inline MX casadi_lt(const MX& x, const MX& y) { return x<y; }
inline MX casadi_le(const MX& x, const MX& y) { return x<=y; }
inline MX casadi_gt(const MX& x, const MX& y) { return x>y; }
inline MX casadi_ge(const MX& x, const MX& y) { return x>=y; }
inline MX casadi_eq(const MX& x, const MX& y) { return x==y; }
inline MX casadi_ne(const MX& x, const MX& y) { return x!=y; }
inline MX casadi_and(const MX& x, const MX& y) { return x&&y; }
inline MX casadi_or(const MX& x, const MX& y) { return x||y; }
inline MX casadi_not(const MX& x) { return !x; }
inline MX casadi_abs(const MX& x) { return fabs(x); }
inline MX casadi_sqrt(const MX& x) { return sqrt(x); }
inline MX casadi_sin(const MX& x) { return sin(x); }
inline MX casadi_cos(const MX& x) { return cos(x); }
inline MX casadi_tan(const MX& x) { return tan(x); }
inline MX casadi_atan(const MX& x) { return atan(x); }
inline MX casadi_asin(const MX& x) { return asin(x); }
inline MX casadi_acos(const MX& x) { return acos(x); }
inline MX casadi_tanh(const MX& x) { return tanh(x); }
inline MX casadi_sinh(const MX& x) { return sinh(x); }
inline MX casadi_cosh(const MX& x) { return cosh(x); }
inline MX casadi_atanh(const MX& x) { return atanh(x); }
inline MX casadi_asinh(const MX& x) { return asinh(x); }
inline MX casadi_acosh(const MX& x) { return acosh(x); }
inline MX casadi_exp(const MX& x) { return exp(x); }
inline MX casadi_log(const MX& x) { return log(x); }
inline MX casadi_log10(const MX& x) { return log10(x); }
inline MX casadi_log1p(const MX& x) { return log1p(x); }
inline MX casadi_expm1(const MX& x) { return expm1(x); }
inline MX casadi_floor(const MX& x) { return floor(x); }
inline MX casadi_ceil(const MX& x) { return ceil(x); }
inline MX casadi_erf(const MX& x) { return erf(x); }
inline MX casadi_erfinv(const MX& x) { using casadi::erfinv; return erfinv(x); }
inline MX casadi_sign(const MX& x) { using casadi::sign; return sign(x); }
inline MX casadi_power(const MX& x, const MX& n) { return pow(x, n); }
inline MX casadi_mod(const MX& x, const MX& y) { return fmod(x, y); }
inline MX casadi_fmod(const MX& x, const MX& y) { return fmod(x, y); }
inline MX casadi_remainder(const MX& x, const MX& y) { return remainder(x, y); }
inline MX casadi_atan2(const MX& x, const MX& y) { return atan2(x, y); }
inline MX casadi_fmin(const MX& x, const MX& y) { return fmin(x, y); }
inline MX casadi_fmax(const MX& x, const MX& y) { return fmax(x, y); }
inline MX casadi_hypot(const MX& x, const MX& y) { return hypot(x, y); }
inline MX casadi_simplify(const MX& x) { using casadi::simplify; return simplify(x); }
inline bool casadi_is_equal(const MX& x, const MX& y, casadi_int depth=0) { using casadi::is_equal; return is_equal(x, y, depth); }
inline MX casadi_copysign(const MX& x, const MX& y) { return copysign(x, y); }
inline MX casadi_constpow(const MX& x, const MX& y) { using casadi::constpow; return constpow(x, y); }

/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3440,GENERIC_EXPRESSION_FUN@*/

inline Matrix<double> casadi_plus(const Matrix<double>& x, const Matrix<double>& y) { return x+y; }
inline Matrix<double> casadi_minus(const Matrix<double>& x, const Matrix<double>& y) { return x-y; }
inline Matrix<double> casadi_times(const Matrix<double>& x, const Matrix<double>& y) { return x*y; }
inline Matrix<double> casadi_rdivide(const Matrix<double>& x, const Matrix<double>& y) { return x/y; }
inline Matrix<double> casadi_ldivide(const Matrix<double>& x, const Matrix<double>& y) { return y/x; }
inline Matrix<double> casadi_lt(const Matrix<double>& x, const Matrix<double>& y) { return x<y; }
inline Matrix<double> casadi_le(const Matrix<double>& x, const Matrix<double>& y) { return x<=y; }
inline Matrix<double> casadi_gt(const Matrix<double>& x, const Matrix<double>& y) { return x>y; }
inline Matrix<double> casadi_ge(const Matrix<double>& x, const Matrix<double>& y) { return x>=y; }
inline Matrix<double> casadi_eq(const Matrix<double>& x, const Matrix<double>& y) { return x==y; }
inline Matrix<double> casadi_ne(const Matrix<double>& x, const Matrix<double>& y) { return x!=y; }
inline Matrix<double> casadi_and(const Matrix<double>& x, const Matrix<double>& y) { return x&&y; }
inline Matrix<double> casadi_or(const Matrix<double>& x, const Matrix<double>& y) { return x||y; }
inline Matrix<double> casadi_not(const Matrix<double>& x) { return !x; }
inline Matrix<double> casadi_abs(const Matrix<double>& x) { return fabs(x); }
inline Matrix<double> casadi_sqrt(const Matrix<double>& x) { return sqrt(x); }
inline Matrix<double> casadi_sin(const Matrix<double>& x) { return sin(x); }
inline Matrix<double> casadi_cos(const Matrix<double>& x) { return cos(x); }
inline Matrix<double> casadi_tan(const Matrix<double>& x) { return tan(x); }
inline Matrix<double> casadi_atan(const Matrix<double>& x) { return atan(x); }
inline Matrix<double> casadi_asin(const Matrix<double>& x) { return asin(x); }
inline Matrix<double> casadi_acos(const Matrix<double>& x) { return acos(x); }
inline Matrix<double> casadi_tanh(const Matrix<double>& x) { return tanh(x); }
inline Matrix<double> casadi_sinh(const Matrix<double>& x) { return sinh(x); }
inline Matrix<double> casadi_cosh(const Matrix<double>& x) { return cosh(x); }
inline Matrix<double> casadi_atanh(const Matrix<double>& x) { return atanh(x); }
inline Matrix<double> casadi_asinh(const Matrix<double>& x) { return asinh(x); }
inline Matrix<double> casadi_acosh(const Matrix<double>& x) { return acosh(x); }
inline Matrix<double> casadi_exp(const Matrix<double>& x) { return exp(x); }
inline Matrix<double> casadi_log(const Matrix<double>& x) { return log(x); }
inline Matrix<double> casadi_log10(const Matrix<double>& x) { return log10(x); }
inline Matrix<double> casadi_log1p(const Matrix<double>& x) { return log1p(x); }
inline Matrix<double> casadi_expm1(const Matrix<double>& x) { return expm1(x); }
inline Matrix<double> casadi_floor(const Matrix<double>& x) { return floor(x); }
inline Matrix<double> casadi_ceil(const Matrix<double>& x) { return ceil(x); }
inline Matrix<double> casadi_erf(const Matrix<double>& x) { return erf(x); }
inline Matrix<double> casadi_erfinv(const Matrix<double>& x) { using casadi::erfinv; return erfinv(x); }
inline Matrix<double> casadi_sign(const Matrix<double>& x) { using casadi::sign; return sign(x); }
inline Matrix<double> casadi_power(const Matrix<double>& x, const Matrix<double>& n) { return pow(x, n); }
inline Matrix<double> casadi_mod(const Matrix<double>& x, const Matrix<double>& y) { return fmod(x, y); }
inline Matrix<double> casadi_fmod(const Matrix<double>& x, const Matrix<double>& y) { return fmod(x, y); }
inline Matrix<double> casadi_remainder(const Matrix<double>& x, const Matrix<double>& y) { return remainder(x, y); }
inline Matrix<double> casadi_atan2(const Matrix<double>& x, const Matrix<double>& y) { return atan2(x, y); }
inline Matrix<double> casadi_fmin(const Matrix<double>& x, const Matrix<double>& y) { return fmin(x, y); }
inline Matrix<double> casadi_fmax(const Matrix<double>& x, const Matrix<double>& y) { return fmax(x, y); }
inline Matrix<double> casadi_hypot(const Matrix<double>& x, const Matrix<double>& y) { return hypot(x, y); }
inline Matrix<double> casadi_simplify(const Matrix<double>& x) { using casadi::simplify; return simplify(x); }
inline bool casadi_is_equal(const Matrix<double>& x, const Matrix<double>& y, casadi_int depth=0) { using casadi::is_equal; return is_equal(x, y, depth); }
inline Matrix<double> casadi_copysign(const Matrix<double>& x, const Matrix<double>& y) { return copysign(x, y); }
inline Matrix<double> casadi_constpow(const Matrix<double>& x, const Matrix<double>& y) { using casadi::constpow; return constpow(x, y); }

/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3440,GENERIC_EXPRESSION_FUN@*/

inline Matrix<SXElem> casadi_plus(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x+y; }
inline Matrix<SXElem> casadi_minus(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x-y; }
inline Matrix<SXElem> casadi_times(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x*y; }
inline Matrix<SXElem> casadi_rdivide(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x/y; }
inline Matrix<SXElem> casadi_ldivide(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return y/x; }
inline Matrix<SXElem> casadi_lt(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x<y; }
inline Matrix<SXElem> casadi_le(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x<=y; }
inline Matrix<SXElem> casadi_gt(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x>y; }
inline Matrix<SXElem> casadi_ge(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x>=y; }
inline Matrix<SXElem> casadi_eq(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x==y; }
inline Matrix<SXElem> casadi_ne(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x!=y; }
inline Matrix<SXElem> casadi_and(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x&&y; }
inline Matrix<SXElem> casadi_or(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return x||y; }
inline Matrix<SXElem> casadi_not(const Matrix<SXElem>& x) { return !x; }
inline Matrix<SXElem> casadi_abs(const Matrix<SXElem>& x) { return fabs(x); }
inline Matrix<SXElem> casadi_sqrt(const Matrix<SXElem>& x) { return sqrt(x); }
inline Matrix<SXElem> casadi_sin(const Matrix<SXElem>& x) { return sin(x); }
inline Matrix<SXElem> casadi_cos(const Matrix<SXElem>& x) { return cos(x); }
inline Matrix<SXElem> casadi_tan(const Matrix<SXElem>& x) { return tan(x); }
inline Matrix<SXElem> casadi_atan(const Matrix<SXElem>& x) { return atan(x); }
inline Matrix<SXElem> casadi_asin(const Matrix<SXElem>& x) { return asin(x); }
inline Matrix<SXElem> casadi_acos(const Matrix<SXElem>& x) { return acos(x); }
inline Matrix<SXElem> casadi_tanh(const Matrix<SXElem>& x) { return tanh(x); }
inline Matrix<SXElem> casadi_sinh(const Matrix<SXElem>& x) { return sinh(x); }
inline Matrix<SXElem> casadi_cosh(const Matrix<SXElem>& x) { return cosh(x); }
inline Matrix<SXElem> casadi_atanh(const Matrix<SXElem>& x) { return atanh(x); }
inline Matrix<SXElem> casadi_asinh(const Matrix<SXElem>& x) { return asinh(x); }
inline Matrix<SXElem> casadi_acosh(const Matrix<SXElem>& x) { return acosh(x); }
inline Matrix<SXElem> casadi_exp(const Matrix<SXElem>& x) { return exp(x); }
inline Matrix<SXElem> casadi_log(const Matrix<SXElem>& x) { return log(x); }
inline Matrix<SXElem> casadi_log10(const Matrix<SXElem>& x) { return log10(x); }
inline Matrix<SXElem> casadi_log1p(const Matrix<SXElem>& x) { return log1p(x); }
inline Matrix<SXElem> casadi_expm1(const Matrix<SXElem>& x) { return expm1(x); }
inline Matrix<SXElem> casadi_floor(const Matrix<SXElem>& x) { return floor(x); }
inline Matrix<SXElem> casadi_ceil(const Matrix<SXElem>& x) { return ceil(x); }
inline Matrix<SXElem> casadi_erf(const Matrix<SXElem>& x) { return erf(x); }
inline Matrix<SXElem> casadi_erfinv(const Matrix<SXElem>& x) { using casadi::erfinv; return erfinv(x); }
inline Matrix<SXElem> casadi_sign(const Matrix<SXElem>& x) { using casadi::sign; return sign(x); }
inline Matrix<SXElem> casadi_power(const Matrix<SXElem>& x, const Matrix<SXElem>& n) { return pow(x, n); }
inline Matrix<SXElem> casadi_mod(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return fmod(x, y); }
inline Matrix<SXElem> casadi_fmod(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return fmod(x, y); }
inline Matrix<SXElem> casadi_remainder(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return remainder(x, y); }
inline Matrix<SXElem> casadi_atan2(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return atan2(x, y); }
inline Matrix<SXElem> casadi_fmin(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return fmin(x, y); }
inline Matrix<SXElem> casadi_fmax(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return fmax(x, y); }
inline Matrix<SXElem> casadi_hypot(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return hypot(x, y); }
inline Matrix<SXElem> casadi_simplify(const Matrix<SXElem>& x) { using casadi::simplify; return simplify(x); }
inline bool casadi_is_equal(const Matrix<SXElem>& x, const Matrix<SXElem>& y, casadi_int depth=0) { using casadi::is_equal; return is_equal(x, y, depth); }
inline Matrix<SXElem> casadi_copysign(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { return copysign(x, y); }
inline Matrix<SXElem> casadi_constpow(const Matrix<SXElem>& x, const Matrix<SXElem>& y) { using casadi::constpow; return constpow(x, y); }

/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3440,GENERIC_EXPRESSION_FUN@*/

inline double casadi_plus(const double& x, const double& y) { return x+y; }
inline double casadi_minus(const double& x, const double& y) { return x-y; }
inline double casadi_times(const double& x, const double& y) { return x*y; }
inline double casadi_rdivide(const double& x, const double& y) { return x/y; }
inline double casadi_ldivide(const double& x, const double& y) { return y/x; }
inline double casadi_lt(const double& x, const double& y) { return x<y; }
inline double casadi_le(const double& x, const double& y) { return x<=y; }
inline double casadi_gt(const double& x, const double& y) { return x>y; }
inline double casadi_ge(const double& x, const double& y) { return x>=y; }
inline double casadi_eq(const double& x, const double& y) { return x==y; }
inline double casadi_ne(const double& x, const double& y) { return x!=y; }
inline double casadi_and(const double& x, const double& y) { return x&&y; }
inline double casadi_or(const double& x, const double& y) { return x||y; }
inline double casadi_not(const double& x) { return !x; }
inline double casadi_abs(const double& x) { return fabs(x); }
inline double casadi_sqrt(const double& x) { return sqrt(x); }
inline double casadi_sin(const double& x) { return sin(x); }
inline double casadi_cos(const double& x) { return cos(x); }
inline double casadi_tan(const double& x) { return tan(x); }
inline double casadi_atan(const double& x) { return atan(x); }
inline double casadi_asin(const double& x) { return asin(x); }
inline double casadi_acos(const double& x) { return acos(x); }
inline double casadi_tanh(const double& x) { return tanh(x); }
inline double casadi_sinh(const double& x) { return sinh(x); }
inline double casadi_cosh(const double& x) { return cosh(x); }
inline double casadi_atanh(const double& x) { return atanh(x); }
inline double casadi_asinh(const double& x) { return asinh(x); }
inline double casadi_acosh(const double& x) { return acosh(x); }
inline double casadi_exp(const double& x) { return exp(x); }
inline double casadi_log(const double& x) { return log(x); }
inline double casadi_log10(const double& x) { return log10(x); }
inline double casadi_log1p(const double& x) { return log1p(x); }
inline double casadi_expm1(const double& x) { return expm1(x); }
inline double casadi_floor(const double& x) { return floor(x); }
inline double casadi_ceil(const double& x) { return ceil(x); }
inline double casadi_erf(const double& x) { return erf(x); }
inline double casadi_erfinv(const double& x) { using casadi::erfinv; return erfinv(x); }
inline double casadi_sign(const double& x) { using casadi::sign; return sign(x); }
inline double casadi_power(const double& x, const double& n) { return pow(x, n); }
inline double casadi_mod(const double& x, const double& y) { return fmod(x, y); }
inline double casadi_fmod(const double& x, const double& y) { return fmod(x, y); }
inline double casadi_remainder(const double& x, const double& y) { return remainder(x, y); }
inline double casadi_atan2(const double& x, const double& y) { return atan2(x, y); }
inline double casadi_fmin(const double& x, const double& y) { return fmin(x, y); }
inline double casadi_fmax(const double& x, const double& y) { return fmax(x, y); }
inline double casadi_hypot(const double& x, const double& y) { return hypot(x, y); }
inline double casadi_simplify(const double& x) { using casadi::simplify; return simplify(x); }
inline bool casadi_is_equal(const double& x, const double& y, casadi_int depth=0) { using casadi::is_equal; return is_equal(x, y, depth); }
inline double casadi_copysign(const double& x, const double& y) { return copysign(x, y); }
inline double casadi_constpow(const double& x, const double& y) { using casadi::constpow; return constpow(x, y); }

/*@SWIG@*/
/*@SWIG@*/
    /*@SWIG:/local/swig/python/../casadi.i,3434,GENERIC_MATRIX_ALL@*/
/*@SWIG:/local/swig/python/../casadi.i,3106,GENERIC_MATRIX_FUN@*/

inline MX casadi_mpower(const MX& x, const MX& n) {
  return mpower(x, n);
}

inline MX casadi_mrdivide(const MX& x, const MX& y) {
  return mrdivide(x, y);
}

inline MX casadi_mldivide(const MX& x, const MX& y) {
  return mldivide(x, y);
}

inline std::vector< MX > casadi_symvar(const MX& x) {
  return symvar(x);
}

inline MX casadi_bilin(const MX& A, const MX& x, const MX& y) {
  return bilin(A, x, y);
}

inline MX casadi_bilin(const MX& A, const MX& x) {
  return bilin(A, x);
}

inline MX casadi_rank1(const MX& A, const MX& alpha, const MX& x, const MX& y) {
  return rank1(A, alpha, x, y);
}

inline MX casadi_sumsqr(const MX& X) {
  return sumsqr(X);
}

inline MX casadi_linspace(const MX& a, const MX& b, casadi_int nsteps) {
  return linspace(a, b, nsteps);
}

inline MX casadi_logsumexp(const MX& a) {
  return logsumexp(a);
}

inline MX casadi_logsumexp(const MX& a, const MX& margin) {
  return logsumexp(a, margin);
}

inline MX casadi_interp1d(const std::vector<double>& x, const MX&v,
        const std::vector<double>& xq, const std::string& mode="linear", bool equidistant=false) {
  return interp1d(x, v, xq, mode, equidistant);
}

inline MX casadi_soc(const MX& x, const MX& y) {
  return soc(x, y);
}

inline MX casadi_cross(const MX& a, const MX& b, casadi_int dim = -1) {
  return cross(a, b, dim);
}

inline MX casadi_skew(const MX& a) {
  return skew(a);
}

inline MX casadi_inv_skew(const MX& a) {
  return inv_skew(a);
}

inline MX casadi_det(const MX& A) {
  return det(A);
}

inline MX casadi_inv_minor(const MX& A) {
  return inv_minor(A);
}

inline MX casadi_inv(const MX& A) {
  return inv(A);
}

inline MX casadi_inv(const MX& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return inv(A, lsolver, opts);
}

inline MX casadi_trace(const MX& a) {
  return trace(a);
}

inline MX casadi_tril2symm(const MX& a) {
  return tril2symm(a);
}

inline MX casadi_triu2symm(const MX& a) {
  return triu2symm(a);
}

inline MX casadi_norm_fro(const MX& x) {
  return norm_fro(x);
}

inline MX casadi_norm_2(const MX& x) {
  return norm_2(x);
}

inline MX casadi_norm_1(const MX& x) {
  return norm_1(x);
}

inline MX casadi_norm_inf(const MX& x) {
  return norm_inf(x);
}

inline MX casadi_dot(const MX& x, const MX& y) {
  return dot(x, y);
}

inline MX casadi_nullspace(const MX& A) {
  return nullspace(A);
}

inline MX casadi_polyval(const MX& p, const MX& x) {
  return polyval(p, x);
}

inline MX casadi_diag(const MX& A) {
  return diag(A);
}

inline MX casadi_unite(const MX& A, const MX& B) {
  return unite(A, B);
}

inline MX casadi_densify(const MX& x) {
  return densify(x);
}

inline MX casadi_project(const MX& A, const Sparsity& sp, bool intersect=false) {
  return project(A, sp, intersect);
}

inline MX casadi_if_else(const MX& cond, const MX& if_true,
                    const MX& if_false, bool short_circuit=false) {
  return if_else(cond, if_true, if_false, short_circuit);
}

inline MX casadi_conditional(const MX& ind, const std::vector< MX > &x,
                        const MX& x_default, bool short_circuit=false) {
  return conditional(ind, x, x_default, short_circuit);
}

inline bool casadi_depends_on(const MX& f, const MX& arg) {
  return depends_on(f, arg);
}

inline MX casadi_solve(const MX& A, const MX& b) {
  return solve(A, b);
}

inline MX casadi_solve(const MX& A, const MX& b,
                       const std::string& lsolver,
                       const casadi::Dict& opts = casadi::Dict()) {
  return solve(A, b, lsolver, opts);
}

inline MX casadi_pinv(const MX& A) {
  return pinv(A);
}

inline MX casadi_pinv(const MX& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return pinv(A, lsolver, opts);
}

inline MX casadi_expm_const(const MX& A, const MX& t) {
  return expm_const(A, t);
}

inline MX casadi_expm(const MX& A) {
  return expm(A);
}

inline MX casadi_jacobian(const MX &ex, const MX &arg, const Dict& opts=Dict()) {
  return jacobian(ex, arg, opts);
}

inline MX casadi_jtimes(const MX& ex, const MX& arg, const MX& v, bool tr=false) {
  return jtimes(ex, arg, v, tr);
}

inline MX casadi_linearize(const MX& f, const MX& x, const MX& x0) {
  return linearize(f, x, x0);
}

inline std::vector<bool> casadi_which_depends(const MX& expr, const MX& var,
                                            casadi_int order=1, bool tr=false) {
  return which_depends(expr, var, order, tr);
}

inline Sparsity casadi_jacobian_sparsity(const MX& f, const MX& x) {
  return jacobian_sparsity(f, x);
}

inline bool casadi_is_linear(const MX& expr, const MX& var) {
  return is_linear(expr, var);
}

inline bool casadi_is_quadratic(const MX& expr, const MX& var) {
  return is_quadratic(expr, var);
}

inline MX casadi_gradient(const MX &ex, const MX &arg) {
  return gradient(ex, arg);
}

inline MX casadi_tangent(const MX &ex, const MX &arg) {
  return tangent(ex, arg);
}

inline MX casadi_hessian(const MX& ex, const MX& arg, MX& OUTPUT1, const casadi::Dict& opts = casadi::Dict()) {
  return hessian(ex, arg, OUTPUT1, opts);
}

inline void casadi_quadratic_coeff(const MX& ex, const MX& arg, MX& OUTPUT1, MX& OUTPUT2, MX& OUTPUT3, bool check=true) {
  quadratic_coeff(ex, arg, OUTPUT1, OUTPUT2, OUTPUT3, check);
}

inline void casadi_linear_coeff(const MX& ex, const MX& arg, MX& OUTPUT1, MX& OUTPUT2, bool check=true) {
  linear_coeff(ex, arg, OUTPUT1, OUTPUT2, check);
}

inline casadi_int casadi_n_nodes(const MX& A) {
  return n_nodes(A);
}

inline std::string casadi_print_operator(const MX& xb,
                                                  const std::vector<std::string>& args) {
  return print_operator(xb, args);
}
inline MX casadi_repsum(const MX& A, casadi_int n, casadi_int m=1) {
  return repsum(A, n, m);
}
inline MX casadi_diff(const MX& A, casadi_int n=1, casadi_index axis=-1) {
  return diff(A, n, axis);
}
inline MX casadi_cumsum(const MX& A, casadi_index axis=-1) {
  return cumsum(A, axis);
}
inline MX casadi_einstein(const MX& A, const MX& B, const MX& C,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, C, dim_a, dim_b, dim_c, a, b, c);
}
inline MX casadi_einstein(const MX& A, const MX& B,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, dim_a, dim_b, dim_c, a, b, c);
}
inline MX casadi_mmin(const MX& x) { return mmin(x); }
inline MX casadi_mmax(const MX& x) { return mmax(x); }
inline casadi::DM casadi_evalf(const MX& x) {
  return evalf(x);
}
inline std::vector<MX> casadi_cse(const std::vector<MX>& e) {
  return cse(e);
}
inline MX casadi_cse(const MX& e) {
  return cse(e);
}




inline std::vector<std::vector< MX > >
casadi_forward(const std::vector< MX > &ex, const std::vector< MX > &arg,
               const std::vector<std::vector< MX > > &v,
               const Dict& opts = Dict()) {
  return forward(ex, arg, v, opts);
}

inline std::vector<std::vector< MX > >
casadi_reverse(const std::vector< MX > &ex, const std::vector< MX > &arg,
               const std::vector<std::vector< MX > > &v,
               const Dict& opts = Dict()) {
  return reverse(ex, arg, v, opts);
}

inline MX casadi_substitute(const MX& ex, const MX& v, const MX& vdef) {
  return substitute(ex, v, vdef);
}

inline std::vector< MX > casadi_substitute(const std::vector< MX >& ex,
                                         const std::vector< MX >& v,
                                         const std::vector< MX >& vdef) {
  return substitute(ex, v, vdef);
}

inline void casadi_substitute_inplace(const std::vector< MX >& v,
                                      std::vector< MX >& INOUT1,
                                      std::vector< MX >& INOUT2,
                                      bool reverse=false) {
  return substitute_inplace(v, INOUT1, INOUT2, reverse);
}

inline void casadi_extract(const std::vector< MX >& ex,
    std::vector< MX >& OUTPUT1,
    std::vector< MX >& OUTPUT2,
    std::vector< MX >& OUTPUT3,
    const Dict& opts = Dict()) {
  OUTPUT1 = ex;
  extract(OUTPUT1, OUTPUT2, OUTPUT3, opts);
}

inline void casadi_shared(const std::vector< MX >& ex,
                               std::vector< MX >& OUTPUT1,
                               std::vector< MX >& OUTPUT2,
                               std::vector< MX >& OUTPUT3,
                               const std::string& v_prefix="v_",
                               const std::string& v_suffix="") {
  OUTPUT1 = ex;
  shared(OUTPUT1, OUTPUT2, OUTPUT3, v_prefix, v_suffix);
}

inline MX casadi_blockcat(const std::vector< std::vector< MX > > &v) {
 return blockcat(v);
}

/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3106,GENERIC_MATRIX_FUN@*/

inline Matrix<double> casadi_mpower(const Matrix<double>& x, const Matrix<double>& n) {
  return mpower(x, n);
}

inline Matrix<double> casadi_mrdivide(const Matrix<double>& x, const Matrix<double>& y) {
  return mrdivide(x, y);
}

inline Matrix<double> casadi_mldivide(const Matrix<double>& x, const Matrix<double>& y) {
  return mldivide(x, y);
}

inline std::vector< Matrix<double> > casadi_symvar(const Matrix<double>& x) {
  return symvar(x);
}

inline Matrix<double> casadi_bilin(const Matrix<double>& A, const Matrix<double>& x, const Matrix<double>& y) {
  return bilin(A, x, y);
}

inline Matrix<double> casadi_bilin(const Matrix<double>& A, const Matrix<double>& x) {
  return bilin(A, x);
}

inline Matrix<double> casadi_rank1(const Matrix<double>& A, const Matrix<double>& alpha, const Matrix<double>& x, const Matrix<double>& y) {
  return rank1(A, alpha, x, y);
}

inline Matrix<double> casadi_sumsqr(const Matrix<double>& X) {
  return sumsqr(X);
}

inline Matrix<double> casadi_linspace(const Matrix<double>& a, const Matrix<double>& b, casadi_int nsteps) {
  return linspace(a, b, nsteps);
}

inline Matrix<double> casadi_logsumexp(const Matrix<double>& a) {
  return logsumexp(a);
}

inline Matrix<double> casadi_logsumexp(const Matrix<double>& a, const Matrix<double>& margin) {
  return logsumexp(a, margin);
}

inline Matrix<double> casadi_interp1d(const std::vector<double>& x, const Matrix<double>&v,
        const std::vector<double>& xq, const std::string& mode="linear", bool equidistant=false) {
  return interp1d(x, v, xq, mode, equidistant);
}

inline Matrix<double> casadi_soc(const Matrix<double>& x, const Matrix<double>& y) {
  return soc(x, y);
}

inline Matrix<double> casadi_cross(const Matrix<double>& a, const Matrix<double>& b, casadi_int dim = -1) {
  return cross(a, b, dim);
}

inline Matrix<double> casadi_skew(const Matrix<double>& a) {
  return skew(a);
}

inline Matrix<double> casadi_inv_skew(const Matrix<double>& a) {
  return inv_skew(a);
}

inline Matrix<double> casadi_det(const Matrix<double>& A) {
  return det(A);
}

inline Matrix<double> casadi_inv_minor(const Matrix<double>& A) {
  return inv_minor(A);
}

inline Matrix<double> casadi_inv(const Matrix<double>& A) {
  return inv(A);
}

inline Matrix<double> casadi_inv(const Matrix<double>& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return inv(A, lsolver, opts);
}

inline Matrix<double> casadi_trace(const Matrix<double>& a) {
  return trace(a);
}

inline Matrix<double> casadi_tril2symm(const Matrix<double>& a) {
  return tril2symm(a);
}

inline Matrix<double> casadi_triu2symm(const Matrix<double>& a) {
  return triu2symm(a);
}

inline Matrix<double> casadi_norm_fro(const Matrix<double>& x) {
  return norm_fro(x);
}

inline Matrix<double> casadi_norm_2(const Matrix<double>& x) {
  return norm_2(x);
}

inline Matrix<double> casadi_norm_1(const Matrix<double>& x) {
  return norm_1(x);
}

inline Matrix<double> casadi_norm_inf(const Matrix<double>& x) {
  return norm_inf(x);
}

inline Matrix<double> casadi_dot(const Matrix<double>& x, const Matrix<double>& y) {
  return dot(x, y);
}

inline Matrix<double> casadi_nullspace(const Matrix<double>& A) {
  return nullspace(A);
}

inline Matrix<double> casadi_polyval(const Matrix<double>& p, const Matrix<double>& x) {
  return polyval(p, x);
}

inline Matrix<double> casadi_diag(const Matrix<double>& A) {
  return diag(A);
}

inline Matrix<double> casadi_unite(const Matrix<double>& A, const Matrix<double>& B) {
  return unite(A, B);
}

inline Matrix<double> casadi_densify(const Matrix<double>& x) {
  return densify(x);
}

inline Matrix<double> casadi_project(const Matrix<double>& A, const Sparsity& sp, bool intersect=false) {
  return project(A, sp, intersect);
}

inline Matrix<double> casadi_if_else(const Matrix<double>& cond, const Matrix<double>& if_true,
                    const Matrix<double>& if_false, bool short_circuit=false) {
  return if_else(cond, if_true, if_false, short_circuit);
}

inline Matrix<double> casadi_conditional(const Matrix<double>& ind, const std::vector< Matrix<double> > &x,
                        const Matrix<double>& x_default, bool short_circuit=false) {
  return conditional(ind, x, x_default, short_circuit);
}

inline bool casadi_depends_on(const Matrix<double>& f, const Matrix<double>& arg) {
  return depends_on(f, arg);
}

inline Matrix<double> casadi_solve(const Matrix<double>& A, const Matrix<double>& b) {
  return solve(A, b);
}

inline Matrix<double> casadi_solve(const Matrix<double>& A, const Matrix<double>& b,
                       const std::string& lsolver,
                       const casadi::Dict& opts = casadi::Dict()) {
  return solve(A, b, lsolver, opts);
}

inline Matrix<double> casadi_pinv(const Matrix<double>& A) {
  return pinv(A);
}

inline Matrix<double> casadi_pinv(const Matrix<double>& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return pinv(A, lsolver, opts);
}

inline Matrix<double> casadi_expm_const(const Matrix<double>& A, const Matrix<double>& t) {
  return expm_const(A, t);
}

inline Matrix<double> casadi_expm(const Matrix<double>& A) {
  return expm(A);
}

inline Matrix<double> casadi_jacobian(const Matrix<double> &ex, const Matrix<double> &arg, const Dict& opts=Dict()) {
  return jacobian(ex, arg, opts);
}

inline Matrix<double> casadi_jtimes(const Matrix<double>& ex, const Matrix<double>& arg, const Matrix<double>& v, bool tr=false) {
  return jtimes(ex, arg, v, tr);
}

inline Matrix<double> casadi_linearize(const Matrix<double>& f, const Matrix<double>& x, const Matrix<double>& x0) {
  return linearize(f, x, x0);
}

inline std::vector<bool> casadi_which_depends(const Matrix<double>& expr, const Matrix<double>& var,
                                            casadi_int order=1, bool tr=false) {
  return which_depends(expr, var, order, tr);
}

inline Sparsity casadi_jacobian_sparsity(const Matrix<double>& f, const Matrix<double>& x) {
  return jacobian_sparsity(f, x);
}

inline bool casadi_is_linear(const Matrix<double>& expr, const Matrix<double>& var) {
  return is_linear(expr, var);
}

inline bool casadi_is_quadratic(const Matrix<double>& expr, const Matrix<double>& var) {
  return is_quadratic(expr, var);
}

inline Matrix<double> casadi_gradient(const Matrix<double> &ex, const Matrix<double> &arg) {
  return gradient(ex, arg);
}

inline Matrix<double> casadi_tangent(const Matrix<double> &ex, const Matrix<double> &arg) {
  return tangent(ex, arg);
}

inline Matrix<double> casadi_hessian(const Matrix<double>& ex, const Matrix<double>& arg, Matrix<double>& OUTPUT1, const casadi::Dict& opts = casadi::Dict()) {
  return hessian(ex, arg, OUTPUT1, opts);
}

inline void casadi_quadratic_coeff(const Matrix<double>& ex, const Matrix<double>& arg, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2, Matrix<double>& OUTPUT3, bool check=true) {
  quadratic_coeff(ex, arg, OUTPUT1, OUTPUT2, OUTPUT3, check);
}

inline void casadi_linear_coeff(const Matrix<double>& ex, const Matrix<double>& arg, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2, bool check=true) {
  linear_coeff(ex, arg, OUTPUT1, OUTPUT2, check);
}

inline casadi_int casadi_n_nodes(const Matrix<double>& A) {
  return n_nodes(A);
}

inline std::string casadi_print_operator(const Matrix<double>& xb,
                                                  const std::vector<std::string>& args) {
  return print_operator(xb, args);
}
inline Matrix<double> casadi_repsum(const Matrix<double>& A, casadi_int n, casadi_int m=1) {
  return repsum(A, n, m);
}
inline Matrix<double> casadi_diff(const Matrix<double>& A, casadi_int n=1, casadi_index axis=-1) {
  return diff(A, n, axis);
}
inline Matrix<double> casadi_cumsum(const Matrix<double>& A, casadi_index axis=-1) {
  return cumsum(A, axis);
}
inline Matrix<double> casadi_einstein(const Matrix<double>& A, const Matrix<double>& B, const Matrix<double>& C,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, C, dim_a, dim_b, dim_c, a, b, c);
}
inline Matrix<double> casadi_einstein(const Matrix<double>& A, const Matrix<double>& B,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, dim_a, dim_b, dim_c, a, b, c);
}
inline Matrix<double> casadi_mmin(const Matrix<double>& x) { return mmin(x); }
inline Matrix<double> casadi_mmax(const Matrix<double>& x) { return mmax(x); }
inline casadi::DM casadi_evalf(const Matrix<double>& x) {
  return evalf(x);
}
inline std::vector<Matrix<double>> casadi_cse(const std::vector<Matrix<double>>& e) {
  return cse(e);
}
inline Matrix<double> casadi_cse(const Matrix<double>& e) {
  return cse(e);
}




inline std::vector<std::vector< Matrix<double> > >
casadi_forward(const std::vector< Matrix<double> > &ex, const std::vector< Matrix<double> > &arg,
               const std::vector<std::vector< Matrix<double> > > &v,
               const Dict& opts = Dict()) {
  return forward(ex, arg, v, opts);
}

inline std::vector<std::vector< Matrix<double> > >
casadi_reverse(const std::vector< Matrix<double> > &ex, const std::vector< Matrix<double> > &arg,
               const std::vector<std::vector< Matrix<double> > > &v,
               const Dict& opts = Dict()) {
  return reverse(ex, arg, v, opts);
}

inline Matrix<double> casadi_substitute(const Matrix<double>& ex, const Matrix<double>& v, const Matrix<double>& vdef) {
  return substitute(ex, v, vdef);
}

inline std::vector< Matrix<double> > casadi_substitute(const std::vector< Matrix<double> >& ex,
                                         const std::vector< Matrix<double> >& v,
                                         const std::vector< Matrix<double> >& vdef) {
  return substitute(ex, v, vdef);
}

inline void casadi_substitute_inplace(const std::vector< Matrix<double> >& v,
                                      std::vector< Matrix<double> >& INOUT1,
                                      std::vector< Matrix<double> >& INOUT2,
                                      bool reverse=false) {
  return substitute_inplace(v, INOUT1, INOUT2, reverse);
}

inline void casadi_extract(const std::vector< Matrix<double> >& ex,
    std::vector< Matrix<double> >& OUTPUT1,
    std::vector< Matrix<double> >& OUTPUT2,
    std::vector< Matrix<double> >& OUTPUT3,
    const Dict& opts = Dict()) {
  OUTPUT1 = ex;
  extract(OUTPUT1, OUTPUT2, OUTPUT3, opts);
}

inline void casadi_shared(const std::vector< Matrix<double> >& ex,
                               std::vector< Matrix<double> >& OUTPUT1,
                               std::vector< Matrix<double> >& OUTPUT2,
                               std::vector< Matrix<double> >& OUTPUT3,
                               const std::string& v_prefix="v_",
                               const std::string& v_suffix="") {
  OUTPUT1 = ex;
  shared(OUTPUT1, OUTPUT2, OUTPUT3, v_prefix, v_suffix);
}

inline Matrix<double> casadi_blockcat(const std::vector< std::vector< Matrix<double> > > &v) {
 return blockcat(v);
}

/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3106,GENERIC_MATRIX_FUN@*/

inline Matrix<SXElem> casadi_mpower(const Matrix<SXElem>& x, const Matrix<SXElem>& n) {
  return mpower(x, n);
}

inline Matrix<SXElem> casadi_mrdivide(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return mrdivide(x, y);
}

inline Matrix<SXElem> casadi_mldivide(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return mldivide(x, y);
}

inline std::vector< Matrix<SXElem> > casadi_symvar(const Matrix<SXElem>& x) {
  return symvar(x);
}

inline Matrix<SXElem> casadi_bilin(const Matrix<SXElem>& A, const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return bilin(A, x, y);
}

inline Matrix<SXElem> casadi_bilin(const Matrix<SXElem>& A, const Matrix<SXElem>& x) {
  return bilin(A, x);
}

inline Matrix<SXElem> casadi_rank1(const Matrix<SXElem>& A, const Matrix<SXElem>& alpha, const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return rank1(A, alpha, x, y);
}

inline Matrix<SXElem> casadi_sumsqr(const Matrix<SXElem>& X) {
  return sumsqr(X);
}

inline Matrix<SXElem> casadi_linspace(const Matrix<SXElem>& a, const Matrix<SXElem>& b, casadi_int nsteps) {
  return linspace(a, b, nsteps);
}

inline Matrix<SXElem> casadi_logsumexp(const Matrix<SXElem>& a) {
  return logsumexp(a);
}

inline Matrix<SXElem> casadi_logsumexp(const Matrix<SXElem>& a, const Matrix<SXElem>& margin) {
  return logsumexp(a, margin);
}

inline Matrix<SXElem> casadi_interp1d(const std::vector<double>& x, const Matrix<SXElem>&v,
        const std::vector<double>& xq, const std::string& mode="linear", bool equidistant=false) {
  return interp1d(x, v, xq, mode, equidistant);
}

inline Matrix<SXElem> casadi_soc(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return soc(x, y);
}

inline Matrix<SXElem> casadi_cross(const Matrix<SXElem>& a, const Matrix<SXElem>& b, casadi_int dim = -1) {
  return cross(a, b, dim);
}

inline Matrix<SXElem> casadi_skew(const Matrix<SXElem>& a) {
  return skew(a);
}

inline Matrix<SXElem> casadi_inv_skew(const Matrix<SXElem>& a) {
  return inv_skew(a);
}

inline Matrix<SXElem> casadi_det(const Matrix<SXElem>& A) {
  return det(A);
}

inline Matrix<SXElem> casadi_inv_minor(const Matrix<SXElem>& A) {
  return inv_minor(A);
}

inline Matrix<SXElem> casadi_inv(const Matrix<SXElem>& A) {
  return inv(A);
}

inline Matrix<SXElem> casadi_inv(const Matrix<SXElem>& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return inv(A, lsolver, opts);
}

inline Matrix<SXElem> casadi_trace(const Matrix<SXElem>& a) {
  return trace(a);
}

inline Matrix<SXElem> casadi_tril2symm(const Matrix<SXElem>& a) {
  return tril2symm(a);
}

inline Matrix<SXElem> casadi_triu2symm(const Matrix<SXElem>& a) {
  return triu2symm(a);
}

inline Matrix<SXElem> casadi_norm_fro(const Matrix<SXElem>& x) {
  return norm_fro(x);
}

inline Matrix<SXElem> casadi_norm_2(const Matrix<SXElem>& x) {
  return norm_2(x);
}

inline Matrix<SXElem> casadi_norm_1(const Matrix<SXElem>& x) {
  return norm_1(x);
}

inline Matrix<SXElem> casadi_norm_inf(const Matrix<SXElem>& x) {
  return norm_inf(x);
}

inline Matrix<SXElem> casadi_dot(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return dot(x, y);
}

inline Matrix<SXElem> casadi_nullspace(const Matrix<SXElem>& A) {
  return nullspace(A);
}

inline Matrix<SXElem> casadi_polyval(const Matrix<SXElem>& p, const Matrix<SXElem>& x) {
  return polyval(p, x);
}

inline Matrix<SXElem> casadi_diag(const Matrix<SXElem>& A) {
  return diag(A);
}

inline Matrix<SXElem> casadi_unite(const Matrix<SXElem>& A, const Matrix<SXElem>& B) {
  return unite(A, B);
}

inline Matrix<SXElem> casadi_densify(const Matrix<SXElem>& x) {
  return densify(x);
}

inline Matrix<SXElem> casadi_project(const Matrix<SXElem>& A, const Sparsity& sp, bool intersect=false) {
  return project(A, sp, intersect);
}

inline Matrix<SXElem> casadi_if_else(const Matrix<SXElem>& cond, const Matrix<SXElem>& if_true,
                    const Matrix<SXElem>& if_false, bool short_circuit=false) {
  return if_else(cond, if_true, if_false, short_circuit);
}

inline Matrix<SXElem> casadi_conditional(const Matrix<SXElem>& ind, const std::vector< Matrix<SXElem> > &x,
                        const Matrix<SXElem>& x_default, bool short_circuit=false) {
  return conditional(ind, x, x_default, short_circuit);
}

inline bool casadi_depends_on(const Matrix<SXElem>& f, const Matrix<SXElem>& arg) {
  return depends_on(f, arg);
}

inline Matrix<SXElem> casadi_solve(const Matrix<SXElem>& A, const Matrix<SXElem>& b) {
  return solve(A, b);
}

inline Matrix<SXElem> casadi_solve(const Matrix<SXElem>& A, const Matrix<SXElem>& b,
                       const std::string& lsolver,
                       const casadi::Dict& opts = casadi::Dict()) {
  return solve(A, b, lsolver, opts);
}

inline Matrix<SXElem> casadi_pinv(const Matrix<SXElem>& A) {
  return pinv(A);
}

inline Matrix<SXElem> casadi_pinv(const Matrix<SXElem>& A, const std::string& lsolver,
                      const casadi::Dict& opts = casadi::Dict()) {
  return pinv(A, lsolver, opts);
}

inline Matrix<SXElem> casadi_expm_const(const Matrix<SXElem>& A, const Matrix<SXElem>& t) {
  return expm_const(A, t);
}

inline Matrix<SXElem> casadi_expm(const Matrix<SXElem>& A) {
  return expm(A);
}

inline Matrix<SXElem> casadi_jacobian(const Matrix<SXElem> &ex, const Matrix<SXElem> &arg, const Dict& opts=Dict()) {
  return jacobian(ex, arg, opts);
}

inline Matrix<SXElem> casadi_jtimes(const Matrix<SXElem>& ex, const Matrix<SXElem>& arg, const Matrix<SXElem>& v, bool tr=false) {
  return jtimes(ex, arg, v, tr);
}

inline Matrix<SXElem> casadi_linearize(const Matrix<SXElem>& f, const Matrix<SXElem>& x, const Matrix<SXElem>& x0) {
  return linearize(f, x, x0);
}

inline std::vector<bool> casadi_which_depends(const Matrix<SXElem>& expr, const Matrix<SXElem>& var,
                                            casadi_int order=1, bool tr=false) {
  return which_depends(expr, var, order, tr);
}

inline Sparsity casadi_jacobian_sparsity(const Matrix<SXElem>& f, const Matrix<SXElem>& x) {
  return jacobian_sparsity(f, x);
}

inline bool casadi_is_linear(const Matrix<SXElem>& expr, const Matrix<SXElem>& var) {
  return is_linear(expr, var);
}

inline bool casadi_is_quadratic(const Matrix<SXElem>& expr, const Matrix<SXElem>& var) {
  return is_quadratic(expr, var);
}

inline Matrix<SXElem> casadi_gradient(const Matrix<SXElem> &ex, const Matrix<SXElem> &arg) {
  return gradient(ex, arg);
}

inline Matrix<SXElem> casadi_tangent(const Matrix<SXElem> &ex, const Matrix<SXElem> &arg) {
  return tangent(ex, arg);
}

inline Matrix<SXElem> casadi_hessian(const Matrix<SXElem>& ex, const Matrix<SXElem>& arg, Matrix<SXElem>& OUTPUT1, const casadi::Dict& opts = casadi::Dict()) {
  return hessian(ex, arg, OUTPUT1, opts);
}

inline void casadi_quadratic_coeff(const Matrix<SXElem>& ex, const Matrix<SXElem>& arg, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2, Matrix<SXElem>& OUTPUT3, bool check=true) {
  quadratic_coeff(ex, arg, OUTPUT1, OUTPUT2, OUTPUT3, check);
}

inline void casadi_linear_coeff(const Matrix<SXElem>& ex, const Matrix<SXElem>& arg, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2, bool check=true) {
  linear_coeff(ex, arg, OUTPUT1, OUTPUT2, check);
}

inline casadi_int casadi_n_nodes(const Matrix<SXElem>& A) {
  return n_nodes(A);
}

inline std::string casadi_print_operator(const Matrix<SXElem>& xb,
                                                  const std::vector<std::string>& args) {
  return print_operator(xb, args);
}
inline Matrix<SXElem> casadi_repsum(const Matrix<SXElem>& A, casadi_int n, casadi_int m=1) {
  return repsum(A, n, m);
}
inline Matrix<SXElem> casadi_diff(const Matrix<SXElem>& A, casadi_int n=1, casadi_index axis=-1) {
  return diff(A, n, axis);
}
inline Matrix<SXElem> casadi_cumsum(const Matrix<SXElem>& A, casadi_index axis=-1) {
  return cumsum(A, axis);
}
inline Matrix<SXElem> casadi_einstein(const Matrix<SXElem>& A, const Matrix<SXElem>& B, const Matrix<SXElem>& C,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, C, dim_a, dim_b, dim_c, a, b, c);
}
inline Matrix<SXElem> casadi_einstein(const Matrix<SXElem>& A, const Matrix<SXElem>& B,
  const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b, const std::vector<casadi_int>& dim_c,
  const std::vector<casadi_int>& a, const std::vector<casadi_int>& b, const std::vector<casadi_int>& c) {
  return einstein(A, B, dim_a, dim_b, dim_c, a, b, c);
}
inline Matrix<SXElem> casadi_mmin(const Matrix<SXElem>& x) { return mmin(x); }
inline Matrix<SXElem> casadi_mmax(const Matrix<SXElem>& x) { return mmax(x); }
inline casadi::DM casadi_evalf(const Matrix<SXElem>& x) {
  return evalf(x);
}
inline std::vector<Matrix<SXElem>> casadi_cse(const std::vector<Matrix<SXElem>>& e) {
  return cse(e);
}
inline Matrix<SXElem> casadi_cse(const Matrix<SXElem>& e) {
  return cse(e);
}




inline std::vector<std::vector< Matrix<SXElem> > >
casadi_forward(const std::vector< Matrix<SXElem> > &ex, const std::vector< Matrix<SXElem> > &arg,
               const std::vector<std::vector< Matrix<SXElem> > > &v,
               const Dict& opts = Dict()) {
  return forward(ex, arg, v, opts);
}

inline std::vector<std::vector< Matrix<SXElem> > >
casadi_reverse(const std::vector< Matrix<SXElem> > &ex, const std::vector< Matrix<SXElem> > &arg,
               const std::vector<std::vector< Matrix<SXElem> > > &v,
               const Dict& opts = Dict()) {
  return reverse(ex, arg, v, opts);
}

inline Matrix<SXElem> casadi_substitute(const Matrix<SXElem>& ex, const Matrix<SXElem>& v, const Matrix<SXElem>& vdef) {
  return substitute(ex, v, vdef);
}

inline std::vector< Matrix<SXElem> > casadi_substitute(const std::vector< Matrix<SXElem> >& ex,
                                         const std::vector< Matrix<SXElem> >& v,
                                         const std::vector< Matrix<SXElem> >& vdef) {
  return substitute(ex, v, vdef);
}

inline void casadi_substitute_inplace(const std::vector< Matrix<SXElem> >& v,
                                      std::vector< Matrix<SXElem> >& INOUT1,
                                      std::vector< Matrix<SXElem> >& INOUT2,
                                      bool reverse=false) {
  return substitute_inplace(v, INOUT1, INOUT2, reverse);
}

inline void casadi_extract(const std::vector< Matrix<SXElem> >& ex,
    std::vector< Matrix<SXElem> >& OUTPUT1,
    std::vector< Matrix<SXElem> >& OUTPUT2,
    std::vector< Matrix<SXElem> >& OUTPUT3,
    const Dict& opts = Dict()) {
  OUTPUT1 = ex;
  extract(OUTPUT1, OUTPUT2, OUTPUT3, opts);
}

inline void casadi_shared(const std::vector< Matrix<SXElem> >& ex,
                               std::vector< Matrix<SXElem> >& OUTPUT1,
                               std::vector< Matrix<SXElem> >& OUTPUT2,
                               std::vector< Matrix<SXElem> >& OUTPUT3,
                               const std::string& v_prefix="v_",
                               const std::string& v_suffix="") {
  OUTPUT1 = ex;
  shared(OUTPUT1, OUTPUT2, OUTPUT3, v_prefix, v_suffix);
}

inline Matrix<SXElem> casadi_blockcat(const std::vector< std::vector< Matrix<SXElem> > > &v) {
 return blockcat(v);
}

/*@SWIG@*/
/*@SWIG@*/
    /*@SWIG:/local/swig/python/../casadi.i,3628,MATRIX_ALL@*/
/*@SWIG:/local/swig/python/../casadi.i,3502,MATRIX_FUN@*/

inline Matrix<double> casadi_all(const Matrix<double>& x) {
  return all(x);
}

inline Matrix<double> casadi_any(const Matrix<double>& x) {
  return any(x);
}

inline Matrix<double> casadi_adj(const Matrix<double>& A) {
  return adj(A);
}

inline Matrix<double> casadi_minor(const Matrix<double>& x, casadi_int i, casadi_int j) {
  return minor(x, i, j);
}

inline Matrix<double> casadi_cofactor(const Matrix<double>& x, casadi_int i, casadi_int j) {
  return cofactor(x, i, j);
}

inline void casadi_qr(const Matrix<double>& A, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2) {
  return qr(A, OUTPUT1, OUTPUT2);
}

inline void casadi_qr_sparse(const Matrix<double>& A, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2, Matrix<double>& OUTPUT3,
          std::vector<casadi_int>& OUTPUT4, std::vector<casadi_int>& OUTPUT5, bool amd=true) {
  return qr_sparse(A, OUTPUT1, OUTPUT2, OUTPUT3, OUTPUT4, OUTPUT5, amd);
}

inline Matrix<double> casadi_qr_solve(const Matrix<double>& b, const Matrix<double>& v, const Matrix<double>& r, const Matrix<double>& beta,
                       const std::vector<casadi_int>& prinv,
                       const std::vector<casadi_int>& pc, bool tr=false) {
  return qr_solve(b, v, r, beta, prinv, pc, tr);
}

inline void casadi_ldl(const Matrix<double>& A, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2, std::vector<casadi_int>& OUTPUT3, bool amd=true) {
  return ldl(A, OUTPUT1, OUTPUT2, OUTPUT3, amd);
}

inline Matrix<double> casadi_ldl_solve(const Matrix<double>& b, const Matrix<double>& D, const Matrix<double>& LT, const std::vector<casadi_int>& p) {
  return ldl_solve(b, D, LT, p);
}

inline Matrix<double> casadi_chol(const Matrix<double>& A) {
  return chol(A);
}

inline Matrix<double> casadi_norm_inf_mul(const Matrix<double>& x, const Matrix<double>& y) {
  return norm_inf_mul(x, y);
}

inline Matrix<double> casadi_sparsify(const Matrix<double>& A, double tol=0) {
  return sparsify(A, tol);
}

inline void casadi_expand(const Matrix<double>& ex, Matrix<double>& OUTPUT1, Matrix<double>& OUTPUT2) {
  expand(ex, OUTPUT1, OUTPUT2);
}

inline Matrix<double> casadi_pw_const(const Matrix<double> &t, const Matrix<double>& tval, const Matrix<double>& val) {
  return pw_const(t, tval, val);
}

inline Matrix<double> casadi_pw_lin(const Matrix<double>& t, const Matrix<double>& tval, const Matrix<double>& val) {
  return pw_lin(t, tval, val);
}

inline Matrix<double> casadi_heaviside(const Matrix<double>& x) {
  return heaviside(x);
}

inline Matrix<double> casadi_rectangle(const Matrix<double>& x) {
  return rectangle(x);
}

inline Matrix<double> casadi_triangle(const Matrix<double>& x) {
  return triangle(x);
}

inline Matrix<double> casadi_ramp(const Matrix<double>& x) {
  return ramp(x);
}

inline Matrix<double> casadi_gauss_quadrature(const Matrix<double>& f, const Matrix<double>& x,
                               const Matrix<double>& a, const Matrix<double>& b,
                               casadi_int order=5) {
  return gauss_quadrature(f, x, a, b, order);
}

inline Matrix<double> casadi_gauss_quadrature(const Matrix<double>& f, const Matrix<double>& x,
                               const Matrix<double>& a, const Matrix<double>& b,
                               casadi_int order, const Matrix<double>& w) {
  return gauss_quadrature(f, x, a, b, order, w);
}

inline Matrix<double> casadi_taylor(const Matrix<double>& ex, const Matrix<double>& x, const Matrix<double>& a=0, casadi_int order=1) {
  return taylor(ex, x, a, order);
}

inline Matrix<double> casadi_mtaylor(const Matrix<double>& ex, const Matrix<double>& x, const Matrix<double>& a, casadi_int order=1) {
  return mtaylor(ex, x, a, order);
}

inline Matrix<double> casadi_mtaylor(const Matrix<double>& ex, const Matrix<double>& x, const Matrix<double>& a, casadi_int order,
                      const std::vector<casadi_int>& order_contributions) {
  return mtaylor(ex, x, a, order, order_contributions);
}

inline Matrix<double> casadi_poly_coeff(const Matrix<double>& ex,
                         const Matrix<double>&x) {
  return poly_coeff(ex, x);
}

inline Matrix<double> casadi_poly_roots(const Matrix<double>& p) {
  return poly_roots(p);
}

inline Matrix<double> casadi_eig_symbolic(const Matrix<double>& m) {
  return eig_symbolic(m);
}


/*@SWIG@*/
/*@SWIG:/local/swig/python/../casadi.i,3502,MATRIX_FUN@*/

inline Matrix<SXElem> casadi_all(const Matrix<SXElem>& x) {
  return all(x);
}

inline Matrix<SXElem> casadi_any(const Matrix<SXElem>& x) {
  return any(x);
}

inline Matrix<SXElem> casadi_adj(const Matrix<SXElem>& A) {
  return adj(A);
}

inline Matrix<SXElem> casadi_minor(const Matrix<SXElem>& x, casadi_int i, casadi_int j) {
  return minor(x, i, j);
}

inline Matrix<SXElem> casadi_cofactor(const Matrix<SXElem>& x, casadi_int i, casadi_int j) {
  return cofactor(x, i, j);
}

inline void casadi_qr(const Matrix<SXElem>& A, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2) {
  return qr(A, OUTPUT1, OUTPUT2);
}

inline void casadi_qr_sparse(const Matrix<SXElem>& A, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2, Matrix<SXElem>& OUTPUT3,
          std::vector<casadi_int>& OUTPUT4, std::vector<casadi_int>& OUTPUT5, bool amd=true) {
  return qr_sparse(A, OUTPUT1, OUTPUT2, OUTPUT3, OUTPUT4, OUTPUT5, amd);
}

inline Matrix<SXElem> casadi_qr_solve(const Matrix<SXElem>& b, const Matrix<SXElem>& v, const Matrix<SXElem>& r, const Matrix<SXElem>& beta,
                       const std::vector<casadi_int>& prinv,
                       const std::vector<casadi_int>& pc, bool tr=false) {
  return qr_solve(b, v, r, beta, prinv, pc, tr);
}

inline void casadi_ldl(const Matrix<SXElem>& A, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2, std::vector<casadi_int>& OUTPUT3, bool amd=true) {
  return ldl(A, OUTPUT1, OUTPUT2, OUTPUT3, amd);
}

inline Matrix<SXElem> casadi_ldl_solve(const Matrix<SXElem>& b, const Matrix<SXElem>& D, const Matrix<SXElem>& LT, const std::vector<casadi_int>& p) {
  return ldl_solve(b, D, LT, p);
}

inline Matrix<SXElem> casadi_chol(const Matrix<SXElem>& A) {
  return chol(A);
}

inline Matrix<SXElem> casadi_norm_inf_mul(const Matrix<SXElem>& x, const Matrix<SXElem>& y) {
  return norm_inf_mul(x, y);
}

inline Matrix<SXElem> casadi_sparsify(const Matrix<SXElem>& A, double tol=0) {
  return sparsify(A, tol);
}

inline void casadi_expand(const Matrix<SXElem>& ex, Matrix<SXElem>& OUTPUT1, Matrix<SXElem>& OUTPUT2) {
  expand(ex, OUTPUT1, OUTPUT2);
}

inline Matrix<SXElem> casadi_pw_const(const Matrix<SXElem> &t, const Matrix<SXElem>& tval, const Matrix<SXElem>& val) {
  return pw_const(t, tval, val);
}

inline Matrix<SXElem> casadi_pw_lin(const Matrix<SXElem>& t, const Matrix<SXElem>& tval, const Matrix<SXElem>& val) {
  return pw_lin(t, tval, val);
}

inline Matrix<SXElem> casadi_heaviside(const Matrix<SXElem>& x) {
  return heaviside(x);
}

inline Matrix<SXElem> casadi_rectangle(const Matrix<SXElem>& x) {
  return rectangle(x);
}

inline Matrix<SXElem> casadi_triangle(const Matrix<SXElem>& x) {
  return triangle(x);
}

inline Matrix<SXElem> casadi_ramp(const Matrix<SXElem>& x) {
  return ramp(x);
}

inline Matrix<SXElem> casadi_gauss_quadrature(const Matrix<SXElem>& f, const Matrix<SXElem>& x,
                               const Matrix<SXElem>& a, const Matrix<SXElem>& b,
                               casadi_int order=5) {
  return gauss_quadrature(f, x, a, b, order);
}

inline Matrix<SXElem> casadi_gauss_quadrature(const Matrix<SXElem>& f, const Matrix<SXElem>& x,
                               const Matrix<SXElem>& a, const Matrix<SXElem>& b,
                               casadi_int order, const Matrix<SXElem>& w) {
  return gauss_quadrature(f, x, a, b, order, w);
}

inline Matrix<SXElem> casadi_taylor(const Matrix<SXElem>& ex, const Matrix<SXElem>& x, const Matrix<SXElem>& a=0, casadi_int order=1) {
  return taylor(ex, x, a, order);
}

inline Matrix<SXElem> casadi_mtaylor(const Matrix<SXElem>& ex, const Matrix<SXElem>& x, const Matrix<SXElem>& a, casadi_int order=1) {
  return mtaylor(ex, x, a, order);
}

inline Matrix<SXElem> casadi_mtaylor(const Matrix<SXElem>& ex, const Matrix<SXElem>& x, const Matrix<SXElem>& a, casadi_int order,
                      const std::vector<casadi_int>& order_contributions) {
  return mtaylor(ex, x, a, order, order_contributions);
}

inline Matrix<SXElem> casadi_poly_coeff(const Matrix<SXElem>& ex,
                         const Matrix<SXElem>&x) {
  return poly_coeff(ex, x);
}

inline Matrix<SXElem> casadi_poly_roots(const Matrix<SXElem>& p) {
  return poly_roots(p);
}

inline Matrix<SXElem> casadi_eig_symbolic(const Matrix<SXElem>& m) {
  return eig_symbolic(m);
}


/*@SWIG@*/
/*@SWIG@*/
    /*@SWIG:/local/swig/python/../casadi.i,3707,MX_ALL@*/
/*@SWIG:/local/swig/python/../casadi.i,3633,MX_FUN@*/

inline MX casadi_find(const MX& x) {
  return find(x);
}
inline MX casadi_low(const MX& v, const MX& p, const Dict& options = Dict()) {
  return low(v, p, options);
}
inline MX casadi_inv_node(const MX& x) {
  return inv_node(x);
}



inline std::vector< MX >
casadi_matrix_expand(const std::vector< MX >& e,
                     const std::vector< MX > &boundary = std::vector< MX >(),
                     const Dict& options = Dict()) {
  return matrix_expand(e, boundary, options);
}

inline MX casadi_matrix_expand(const MX& e,
                            const std::vector< MX > &boundary = std::vector< MX >(),
                            const Dict& options = Dict()) {
  return matrix_expand(e, boundary, options);
}

inline MX casadi_graph_substitute(const MX& ex, const std::vector< MX >& v,
                         const std::vector< MX > &vdef) {
  return graph_substitute(ex, v, vdef);
}

inline std::vector< MX >
casadi_graph_substitute(const std::vector< MX > &ex,
                 const std::vector< MX > &v,
                 const std::vector< MX > &vdef) {
  return graph_substitute(ex, v, vdef);
}
inline MX casadi_bspline(const MX& x,
        const DM& coeffs,
        const std::vector< std::vector<double> >& knots,
        const std::vector<casadi_int>& degree,
        casadi_int m,
        const Dict& opts = Dict()) {
  return bspline(x, coeffs, knots, degree, m, opts);
}
inline MX casadi_bspline(const MX& x,
        const MX& coeffs,
        const std::vector< std::vector<double> >& knots,
        const std::vector<casadi_int>& degree,
        casadi_int m,
        const Dict& opts = Dict()) {
  return bspline(x, coeffs, knots, degree, m, opts);
}
inline MX casadi_convexify(const MX& H,
        const Dict& opts = Dict()) {
  return convexify(H, opts);
}
inline MX casadi_stop_diff(const MX& expr, casadi_int order) {
  return stop_diff(expr, order);
}
inline MX casadi_stop_diff(const MX& expr, const MX& var, casadi_int order) {
  return stop_diff(expr, var, order);
}
inline MX casadi_no_hess(const MX& expr) {
  return no_hess(expr);
}
inline MX casadi_no_grad(const MX& expr) {
  return no_grad(expr);
}


/*@SWIG@*/
/*@SWIG@*/
  }



/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "casadiPYTHON_wrap.h"

SwigDirector_Callback::SwigDirector_Callback(PyObject *self): casadi::Callback(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((casadi::Callback *)this, this); 
}




SwigDirector_Callback::SwigDirector_Callback(PyObject *self, casadi::Callback const &obj): casadi::Callback(obj), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((casadi::Callback *)this, this); 
}




SwigDirector_Callback::~SwigDirector_Callback() {
}

void SwigDirector_Callback::init() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"init");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
}


void SwigDirector_Callback::finalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "finalize";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"finalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
}


std::vector< casadi::DM,std::allocator< casadi::DM > > SwigDirector_Callback::eval(std::vector< casadi::DM,std::allocator< casadi::DM > > const &arg) const {
  std::vector< casadi::DM,std::allocator< casadi::DM > > c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ptr(&arg))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "DM" "]" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "eval";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"eval");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""std::vector< casadi::DM,std::allocator< casadi::DM > >""'");
  }
  return (std::vector< casadi::DM,std::allocator< casadi::DM > >) c_result;
}


int SwigDirector_Callback::eval_buffer(double const **arg, std::vector< casadi_int,std::allocator< casadi_int > > const &sizes_arg, double **res, std::vector< casadi_int,std::allocator< casadi_int > > const &sizes_res) const {
  int c_result;
  swig::SwigVar_PyObject obj0;
  PyObject * arg_tuple = PyTuple_New((&sizes_arg)->size());
  for (casadi_int i=0;i<(&sizes_arg)->size();++i) {
    PyObject* buf = arg[i] ? PyMemoryView_FromMemory(reinterpret_cast<char*>(const_cast<double*>(arg[i])), sizes_arg[i]*sizeof(double), PyBUF_READ) : SWIG_Py_Void();
    
    
    
    PyTuple_SET_ITEM(arg_tuple, i, buf);
  }
  obj0 = arg_tuple;
  swig::SwigVar_PyObject obj1;
  PyObject* res_tuple = PyTuple_New((&sizes_res)->size());
  for (casadi_int i=0;i<(&sizes_res)->size();++i) {
    PyObject* buf = res[i] ? PyMemoryView_FromMemory(reinterpret_cast<char*>(const_cast<double*>(res[i])), sizes_res[i]*sizeof(double), PyBUF_WRITE) : SWIG_Py_Void();
    
    
    
    PyTuple_SET_ITEM(res_tuple, i, buf);
  }
  obj1 = res_tuple;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "eval_buffer";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"eval_buffer");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_Callback::has_eval_buffer() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "has_eval_buffer";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"has_eval_buffer");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


casadi_int SwigDirector_Callback::get_n_in() {
  casadi_int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "get_n_in";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_n_in");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi_int""'");
  }
  return (casadi_int) c_result;
}


casadi_int SwigDirector_Callback::get_n_out() {
  casadi_int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "get_n_out";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_n_out");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi_int""'");
  }
  return (casadi_int) c_result;
}


casadi::Sparsity SwigDirector_Callback::get_sparsity_in(casadi_int i) {
  casadi::Sparsity c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(i))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "get_sparsity_in";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_sparsity_in");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Sparsity""'");
  }
  return (casadi::Sparsity) c_result;
}


casadi::Sparsity SwigDirector_Callback::get_sparsity_out(casadi_int i) {
  casadi::Sparsity c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(i))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "get_sparsity_out";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_sparsity_out");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Sparsity""'");
  }
  return (casadi::Sparsity) c_result;
}


std::string SwigDirector_Callback::get_name_in(casadi_int i) {
  std::string c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(i))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "get_name_in";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_name_in");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""std::string""'");
  }
  return (std::string) c_result;
}


std::string SwigDirector_Callback::get_name_out(casadi_int i) {
  std::string c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(i))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "get_name_out";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_name_out");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""std::string""'");
  }
  return (std::string) c_result;
}


bool SwigDirector_Callback::uses_output() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "uses_output";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"uses_output");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


bool SwigDirector_Callback::has_jacobian() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char * const swig_method_name = "has_jacobian";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"has_jacobian");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


casadi::Function SwigDirector_Callback::get_jacobian(std::string const &name, std::vector< std::string,std::allocator< std::string > > const &inames, std::vector< std::string,std::allocator< std::string > > const &onames, casadi::Dict const &opts) const {
  casadi::Function c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ptr(&name))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "str" ".""'");
  swig::SwigVar_PyObject obj1;
  if(!(obj1 = casadi::from_ptr(&inames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj2;
  if(!(obj2 = casadi::from_ptr(&onames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj3;
  if(!(obj3 = casadi::from_ptr(&opts))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "dict" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "get_jacobian";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_jacobian");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Function""'");
  }
  return (casadi::Function) c_result;
}


bool SwigDirector_Callback::has_forward(casadi_int nfwd) const {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(nfwd))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "has_forward";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"has_forward");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


casadi::Function SwigDirector_Callback::get_forward(casadi_int nfwd, std::string const &name, std::vector< std::string,std::allocator< std::string > > const &inames, std::vector< std::string,std::allocator< std::string > > const &onames, casadi::Dict const &opts) const {
  casadi::Function c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(nfwd))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  swig::SwigVar_PyObject obj1;
  if(!(obj1 = casadi::from_ptr(&name))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "str" ".""'");
  swig::SwigVar_PyObject obj2;
  if(!(obj2 = casadi::from_ptr(&inames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj3;
  if(!(obj3 = casadi::from_ptr(&onames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj4;
  if(!(obj4 = casadi::from_ptr(&opts))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "dict" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char * const swig_method_name = "get_forward";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_forward");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Function""'");
  }
  return (casadi::Function) c_result;
}


bool SwigDirector_Callback::has_reverse(casadi_int nadj) const {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(nadj))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char * const swig_method_name = "has_reverse";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"has_reverse");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


casadi::Function SwigDirector_Callback::get_reverse(casadi_int nadj, std::string const &name, std::vector< std::string,std::allocator< std::string > > const &inames, std::vector< std::string,std::allocator< std::string > > const &onames, casadi::Dict const &opts) const {
  casadi::Function c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(nadj))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  swig::SwigVar_PyObject obj1;
  if(!(obj1 = casadi::from_ptr(&name))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "str" ".""'");
  swig::SwigVar_PyObject obj2;
  if(!(obj2 = casadi::from_ptr(&inames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj3;
  if(!(obj3 = casadi::from_ptr(&onames))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "[" "str" "]" ".""'");
  swig::SwigVar_PyObject obj4;
  if(!(obj4 = casadi::from_ptr(&opts))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "dict" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "get_reverse";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_reverse");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Function""'");
  }
  return (casadi::Function) c_result;
}


bool SwigDirector_Callback::has_jac_sparsity(casadi_int oind, casadi_int iind) const {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(oind))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  swig::SwigVar_PyObject obj1;
  if(!(obj1 = casadi::from_ref(iind))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char * const swig_method_name = "has_jac_sparsity";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"has_jac_sparsity");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""bool""'");
  }
  return (bool) c_result;
}


casadi::Sparsity SwigDirector_Callback::get_jac_sparsity(casadi_int oind, casadi_int iind, bool symmetric) const {
  casadi::Sparsity c_result;
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(oind))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  swig::SwigVar_PyObject obj1;
  if(!(obj1 = casadi::from_ref(iind))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  swig::SwigVar_PyObject obj2;
  if(!(obj2 = casadi::from_ref(symmetric))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "bool" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char * const swig_method_name = "get_jac_sparsity";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"get_jac_sparsity");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
  if (!casadi::to_val(result, &c_result)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""casadi::Sparsity""'");
  }
  return (casadi::Sparsity) c_result;
}


SwigDirector_OptiCallback::SwigDirector_OptiCallback(PyObject *self): casadi::OptiCallback(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((casadi::OptiCallback *)this, this); 
}




SwigDirector_OptiCallback::SwigDirector_OptiCallback(PyObject *self, casadi::OptiCallback const &obj): casadi::OptiCallback(obj), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((casadi::OptiCallback *)this, this); 
}




void SwigDirector_OptiCallback::call(casadi_int i) {
  swig::SwigVar_PyObject obj0;
  if(!(obj0 = casadi::from_ref(i))) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(SWIG_TypeError)), "in output value of type '""For director inputs, failed to convert input to " "int" ".""'");
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call OptiCallback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "call";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"call");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) casadi::handle_director_exception();
    }
  }
}


SwigDirector_OptiCallback::~SwigDirector_OptiCallback() {
}

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SwigPyIterator'.\n"
    "  Prototype:\n"
    "SwigPyIterator(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_value'.\n"
    "  Prototype:\n"
    "value(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 = (size_t) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_incr",1,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_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  if (swig_obj[1]) {
    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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_incr'.\n"
    "  Prototype:\n"
    "incr(self,size_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 = (size_t) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_decr",1,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_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  if (swig_obj[1]) {
    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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_decr'.\n"
    "  Prototype:\n"
    "decr(self,size_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_distance'.\n"
    "  Prototype:\n"
    "distance(self,SwigPyIterator)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_equal'.\n"
    "  Prototype:\n"
    "equal(self,SwigPyIterator)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_copy'.\n"
    "  Prototype:\n"
    "copy(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_next'.\n"
    "  Prototype:\n"
    "next(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___next__'.\n"
    "  Prototype:\n"
    "__next__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_previous'.\n"
    "  Prototype:\n"
    "previous(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator_advance'.\n"
    "  Prototype:\n"
    "advance(self,ptrdiff_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___eq__'.\n"
    "  Prototype:\n"
    "__eq__(self,SwigPyIterator)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___ne__'.\n"
    "  Prototype:\n"
    "__ne__(self,SwigPyIterator)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___iadd__'.\n"
    "  Prototype:\n"
    "__iadd__(self,ptrdiff_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___isub__'.\n"
    "  Prototype:\n"
    "__isub__(self,ptrdiff_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___add__'.\n"
    "  Prototype:\n"
    "__add__(self,ptrdiff_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___sub__'.\n"
    "  Prototype:\n"
    "__sub__(self,ptrdiff_t)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SwigPyIterator___sub__'.\n"
    "  Prototype:\n"
    "__sub__(self,SwigPyIterator)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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

SWIGINTERN PyObject *_wrap_new_PrintableCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::PrintableCommon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::PrintableCommon *)new casadi::PrintableCommon();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__PrintableCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_PrintableCommon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrintableCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::PrintableCommon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::PrintableCommon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__PrintableCommon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrintableCommon" "', argument " "1"" of type '" "casadi::PrintableCommon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrintableCommon" "', argument " "1"" of type '" "casadi::PrintableCommon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::PrintableCommon * >(argp1);
  {
    result = (casadi::PrintableCommon *)new casadi::PrintableCommon((casadi::PrintableCommon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__PrintableCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_PrintableCommon'.\n"
    "  Prototype:\n"
    "PrintableCommon(PrintableCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrintableCommon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PrintableCommon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PrintableCommon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__PrintableCommon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrintableCommon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_PrintableCommon'.\n"
    "  Possible prototypes are:\n"
    "    PrintableCommon()\n"
    "    PrintableCommon(PrintableCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PrintableCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::PrintableCommon *arg1 = (casadi::PrintableCommon *) 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_casadi__PrintableCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PrintableCommon" "', argument " "1"" of type '" "casadi::PrintableCommon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::PrintableCommon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_PrintableCommon'.\n"
    "  Prototype:\n"
    "PrintableCommon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_SharedObject_class_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 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_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject_class_name" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    try {
      result = ((casadi::SharedObject const *)arg1)->class_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject_class_name'.\n"
    "  Prototype:\n"
    "class_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SharedObject_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SharedObject_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject_disp" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::SharedObject const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SharedObject_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"SharedObject_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject_str" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::SharedObject const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SharedObject_print_ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 0 ;
  std::ostream &arg2_defvalue = casadi::uout() ;
  std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject_print_ptr" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    try {
      ((casadi::SharedObject const *)arg1)->print_ptr(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject_print_ptr'.\n"
    "  Prototype:\n"
    "print_ptr(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SharedObject_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 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_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject_is_null" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    try {
      result = (bool)((casadi::SharedObject const *)arg1)->is_null();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject_is_null'.\n"
    "  Prototype:\n"
    "is_null(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SharedObject___hash__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SharedObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SharedObject___hash__" "', argument " "1"" of type '" "casadi::SharedObject const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::SharedObject const *)arg1)->__hash__();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SharedObject___hash__'.\n"
    "  Prototype:\n"
    "__hash__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::SharedObject *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::SharedObject *)new casadi::SharedObject();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SharedObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_SharedObject'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::SharedObject *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__SharedObject,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SharedObject" "', argument " "1"" of type '" "casadi::SharedObject const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SharedObject" "', argument " "1"" of type '" "casadi::SharedObject const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    result = (casadi::SharedObject *)new casadi::SharedObject((casadi::SharedObject const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SharedObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SharedObject'.\n"
    "  Prototype:\n"
    "SharedObject(SharedObject)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SharedObject",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SharedObject__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__SharedObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SharedObject__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_SharedObject'.\n"
    "  Possible prototypes are:\n"
    "    SharedObject()\n"
    "    SharedObject(SharedObject)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SharedObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObject *arg1 = (casadi::SharedObject *) 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_casadi__SharedObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedObject" "', argument " "1"" of type '" "casadi::SharedObject *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObject * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SharedObject'.\n"
    "  Prototype:\n"
    "SharedObject(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_WeakRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 = (int) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  casadi::WeakRef *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 1)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WeakRef" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  {
    try {
      result = (casadi::WeakRef *)new casadi::WeakRef(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__WeakRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_WeakRef'.\n"
    "  Prototype:\n"
    "WeakRef(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WeakRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SharedObject arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  casadi::WeakRef *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__SharedObject,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WeakRef" "', argument " "1"" of type '" "casadi::SharedObject""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WeakRef" "', argument " "1"" of type '" "casadi::SharedObject""'");
    } else {
      casadi::SharedObject * temp = reinterpret_cast< casadi::SharedObject * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (casadi::WeakRef *)new casadi::WeakRef(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__WeakRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_WeakRef'.\n"
    "  Prototype:\n"
    "WeakRef(SharedObject)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakRef_shared(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::WeakRef *arg1 = (casadi::WeakRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::SharedObject result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__WeakRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakRef_shared" "', argument " "1"" of type '" "casadi::WeakRef *""'"); 
  }
  arg1 = reinterpret_cast< casadi::WeakRef * >(argp1);
  {
    try {
      result = (arg1)->shared();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::SharedObject(static_cast< const casadi::SharedObject& >(result))), SWIGTYPE_p_casadi__SharedObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'WeakRef_shared'.\n"
    "  Prototype:\n"
    "shared(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakRef_alive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::WeakRef *arg1 = (casadi::WeakRef *) 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_casadi__WeakRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakRef_alive" "', argument " "1"" of type '" "casadi::WeakRef const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::WeakRef * >(argp1);
  {
    try {
      result = (bool)((casadi::WeakRef const *)arg1)->alive();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'WeakRef_alive'.\n"
    "  Prototype:\n"
    "alive(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WeakRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::WeakRef *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::WeakRef *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__WeakRef,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WeakRef" "', argument " "1"" of type '" "casadi::WeakRef const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WeakRef" "', argument " "1"" of type '" "casadi::WeakRef const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::WeakRef * >(argp1);
  {
    result = (casadi::WeakRef *)new casadi::WeakRef((casadi::WeakRef const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__WeakRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_WeakRef'.\n"
    "  Prototype:\n"
    "WeakRef(WeakRef)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WeakRef(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_WeakRef",0,1,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 1)) {
    int _v;
    if (argc <= 0) {
      return _wrap_new_WeakRef__SWIG_0(self, argc, argv);
    }
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_WeakRef__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__WeakRef, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WeakRef__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__SharedObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WeakRef__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_WeakRef'.\n"
    "  Possible prototypes are:\n"
    "    WeakRef(int)\n"
    "    WeakRef(WeakRef)\n"
    "    WeakRef(SharedObject)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WeakRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::WeakRef *arg1 = (casadi::WeakRef *) 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_casadi__WeakRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WeakRef" "', argument " "1"" of type '" "casadi::WeakRef *""'"); 
  }
  arg1 = reinterpret_cast< casadi::WeakRef * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_WeakRef'.\n"
    "  Prototype:\n"
    "WeakRef(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_complement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  casadi_int arg2 ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"complement",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::complement((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'complement'.\n"
    "  Prototype:\n"
    "complement([int],int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lookupvector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  casadi_int arg2 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::lookupvector((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lookupvector'.\n"
    "  Prototype:\n"
    "lookupvector([int],int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lookupvector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::lookupvector((std::vector< long long,std::allocator< long long > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lookupvector'.\n"
    "  Prototype:\n"
    "lookupvector([int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lookupvector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"lookupvector",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      return _wrap_lookupvector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_lookupvector__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'lookupvector'.\n"
    "  Possible prototypes are:\n"
    "    lookupvector([int])\n"
    "    lookupvector([int],int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_temporary_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"temporary_file",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::temporary_file((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'temporary_file'.\n"
    "  Prototype:\n"
    "temporary_file(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_normalized_setup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "normalized_setup" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "normalized_setup" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    try {
      casadi::normalized_setup(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'normalized_setup'.\n"
    "  Prototype:\n"
    "normalized_setup(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_normalized_setup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  
  arg1 = &casadi::uout();
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      casadi::normalized_setup(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'normalized_setup'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_normalized_setup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"normalized_setup",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_normalized_setup__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_normalized_setup__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'normalized_setup'.\n"
    "  Possible prototypes are:\n"
    "    normalized_setup()\n"
    "    normalized_setup(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_normalized_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  double arg2 ;
  PyObject *swig_obj[1] ;
  
  arg1 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      casadi::normalized_out(*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'normalized_out'.\n"
    "  Prototype:\n"
    "normalized_out(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_normalized_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"normalized_in",2,2,swig_obj)) 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 '" "normalized_in" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "normalized_in" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "normalized_in" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "normalized_in" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  {
    try {
      result = (int)casadi::normalized_in(*arg1,*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'normalized_in'.\n"
    "  Prototype:\n"
    "normalized_in(std::istream &,double &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericType_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericType *arg1 = (casadi::GenericType *) 0 ;
  casadi::SerializingStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"GenericType_serialize",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericType_serialize" "', argument " "1"" of type '" "casadi::GenericType const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericType_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericType_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::GenericType const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenericType_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenericType_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::GenericType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericType_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericType_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::GenericType::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "GenericType" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenericType_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericType *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericType *)new casadi::GenericType();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenericType'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericType *arg1 = 0 ;
  casadi::GenericType m1 ;
  casadi::GenericType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "GenericType" "'.");
  {
    result = (casadi::GenericType *)new casadi::GenericType((casadi::GenericType const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenericType'.\n"
    "  Prototype:\n"
    "GenericType(GenericType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenericType",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenericType__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::GenericType **>(0));
    if (_v) {
      return _wrap_new_GenericType__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenericType'.\n"
    "  Possible prototypes are:\n"
    "    GenericType()\n"
    "    GenericType(GenericType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenericType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericType *arg1 = (casadi::GenericType *) 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_casadi__GenericType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericType" "', argument " "1"" of type '" "casadi::GenericType *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericType * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenericType'.\n"
    "  Prototype:\n"
    "GenericType(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SparsityInterfaceCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::SparsityInterfaceCommon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::SparsityInterfaceCommon *)new casadi::SparsityInterfaceCommon();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SparsityInterfaceCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_SparsityInterfaceCommon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SparsityInterfaceCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SparsityInterfaceCommon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::SparsityInterfaceCommon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__SparsityInterfaceCommon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SparsityInterfaceCommon" "', argument " "1"" of type '" "casadi::SparsityInterfaceCommon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparsityInterfaceCommon" "', argument " "1"" of type '" "casadi::SparsityInterfaceCommon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::SparsityInterfaceCommon * >(argp1);
  {
    result = (casadi::SparsityInterfaceCommon *)new casadi::SparsityInterfaceCommon((casadi::SparsityInterfaceCommon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SparsityInterfaceCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SparsityInterfaceCommon'.\n"
    "  Prototype:\n"
    "SparsityInterfaceCommon(SparsityInterfaceCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SparsityInterfaceCommon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SparsityInterfaceCommon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SparsityInterfaceCommon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__SparsityInterfaceCommon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SparsityInterfaceCommon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_SparsityInterfaceCommon'.\n"
    "  Possible prototypes are:\n"
    "    SparsityInterfaceCommon()\n"
    "    SparsityInterfaceCommon(SparsityInterfaceCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SparsityInterfaceCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SparsityInterfaceCommon *arg1 = (casadi::SparsityInterfaceCommon *) 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_casadi__SparsityInterfaceCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SparsityInterfaceCommon" "', argument " "1"" of type '" "casadi::SparsityInterfaceCommon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SparsityInterfaceCommon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SparsityInterfaceCommon'.\n"
    "  Prototype:\n"
    "SparsityInterfaceCommon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Sparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 0 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 1)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  {
    try {
      result = (casadi::Sparsity *)new casadi::Sparsity(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::Sparsity *)new casadi::Sparsity(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sparsity__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  bool arg5 = (bool) false ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = (casadi::Sparsity *)new casadi::Sparsity(arg1,arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity(int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sparsity__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = (casadi::Sparsity *)new casadi::Sparsity((std::pair< casadi_int,casadi_int > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 = (bool) true ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_scalar",0,1,swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::Sparsity::scalar(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_scalar'.\n"
    "  Prototype:\n"
    "scalar(bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_dense__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Sparsity::dense(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_dense'.\n"
    "  Prototype:\n"
    "dense(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_dense__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Sparsity::dense((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_dense'.\n"
    "  Prototype:\n"
    "dense((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_dense(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_dense",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_Sparsity_dense__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Sparsity_dense__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_Sparsity_dense__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_dense'.\n"
    "  Possible prototypes are:\n"
    "    dense(int,int)\n"
    "    dense((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_unit",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::unit(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_unit'.\n"
    "  Prototype:\n"
    "unit(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::upper(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_upper'.\n"
    "  Prototype:\n"
    "upper(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::lower(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_lower'.\n"
    "  Prototype:\n"
    "lower(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_diag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::diag(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_diag'.\n"
    "  Prototype:\n"
    "diag(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_diag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::diag(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_diag'.\n"
    "  Prototype:\n"
    "diag(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_diag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Sparsity::diag((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_diag'.\n"
    "  Prototype:\n"
    "diag((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_diag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_diag",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_Sparsity_diag__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_Sparsity_diag__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Sparsity_diag__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_diag'.\n"
    "  Possible prototypes are:\n"
    "    diag(int)\n"
    "    diag((int,int))\n"
    "    diag(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_band(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_band",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::band(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_band'.\n"
    "  Prototype:\n"
    "band(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_banded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_banded",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::banded(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_banded'.\n"
    "  Prototype:\n"
    "banded(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_rowcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[4] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_rowcol",4,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::Sparsity::rowcol((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_rowcol'.\n"
    "  Prototype:\n"
    "rowcol([int],[int],int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_triplet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  casadi::Sparsity result;
  
  arg5 = &m5;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[4], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  {
    try {
      result = casadi::Sparsity::triplet(arg1,arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_triplet'.\n"
    "  Prototype:\n"
    "triplet(int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_triplet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Sparsity result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::Sparsity::triplet(arg1,arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_triplet'.\n"
    "  Prototype:\n"
    "triplet(int,int,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_triplet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_triplet",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            return _wrap_Sparsity_triplet__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_Sparsity_triplet__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_triplet'.\n"
    "  Possible prototypes are:\n"
    "    triplet(int,int,[int],[int])\n"
    "    triplet(int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_nonzeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[4] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_nonzeros",3,4,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::Sparsity::nonzeros(arg1,arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_nonzeros'.\n"
    "  Prototype:\n"
    "nonzeros(int,int,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_compressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_compressed",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::Sparsity::compressed((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_compressed'.\n"
    "  Prototype:\n"
    "compressed([int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_permutation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_permutation",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::Sparsity::permutation((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_permutation'.\n"
    "  Prototype:\n"
    "permutation([int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_permutation_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_permutation_vector",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_permutation_vector" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->permutation_vector(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_permutation_vector'.\n"
    "  Prototype:\n"
    "permutation_vector(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  arg2 = &m2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_diag" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_diag(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_diag'.\n"
    "  Prototype:\n"
    "get_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_compress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_compress" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->compress();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_compress'.\n"
    "  Prototype:\n"
    "compress(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_equal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_equal" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_equal((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_equal'.\n"
    "  Prototype:\n"
    "is_equal(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_equal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  bool result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_equal" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_equal(arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_equal'.\n"
    "  Prototype:\n"
    "is_equal(self,int,int,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_equal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_is_equal",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_Sparsity_is_equal__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              return _wrap_Sparsity_is_equal__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_is_equal'.\n"
    "  Possible prototypes are:\n"
    "    is_equal(self,Sparsity)\n"
    "    is_equal(self,int,int,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity___eq__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity___eq__" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->operator ==((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity___eq__'.\n"
    "  Prototype:\n"
    "__eq__(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity___ne__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity___ne__" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->operator !=((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity___ne__'.\n"
    "  Prototype:\n"
    "__ne__(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_stacked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_stacked",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_stacked" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_stacked((casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_stacked'.\n"
    "  Prototype:\n"
    "is_stacked(self,Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_size1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_size1" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->size1();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_size1'.\n"
    "  Prototype:\n"
    "size1(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_rows" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->rows();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_rows'.\n"
    "  Prototype:\n"
    "rows(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_size2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_size2" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->size2();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_size2'.\n"
    "  Prototype:\n"
    "size2(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_columns" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->columns();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_columns'.\n"
    "  Prototype:\n"
    "columns(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_numel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_numel" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->numel();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_numel'.\n"
    "  Prototype:\n"
    "numel(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_density(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_density" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (double)((casadi::Sparsity const *)arg1)->density();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_density'.\n"
    "  Prototype:\n"
    "density(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_empty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_empty" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_empty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_empty'.\n"
    "  Prototype:\n"
    "is_empty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_nnz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_nnz" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->nnz();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_nnz'.\n"
    "  Prototype:\n"
    "nnz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_nnz_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_nnz_upper",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_nnz_upper" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->nnz_upper(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_nnz_upper'.\n"
    "  Prototype:\n"
    "nnz_upper(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_nnz_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_nnz_lower",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_nnz_lower" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->nnz_lower(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_nnz_lower'.\n"
    "  Prototype:\n"
    "nnz_lower(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_nnz_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_nnz_diag" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->nnz_diag();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_nnz_diag'.\n"
    "  Prototype:\n"
    "nnz_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_bw_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_bw_upper" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->bw_upper();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_bw_upper'.\n"
    "  Prototype:\n"
    "bw_upper(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_bw_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_bw_lower" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->bw_lower();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_bw_lower'.\n"
    "  Prototype:\n"
    "bw_lower(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_size" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->size();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_size'.\n"
    "  Prototype:\n"
    "size(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_size" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->size(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_size'.\n"
    "  Prototype:\n"
    "size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_size",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_size__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Sparsity_size__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_size'.\n"
    "  Possible prototypes are:\n"
    "    size(self)\n"
    "    size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_info" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_to_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::string *arg2 = 0 ;
  std::string const &arg3_defvalue = "" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_to_file",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_to_file" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      ((casadi::Sparsity const *)arg1)->to_file((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_to_file'.\n"
    "  Prototype:\n"
    "to_file(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_from_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string const &arg2_defvalue = "" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_from_file",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = casadi::Sparsity::from_file((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_from_file'.\n"
    "  Prototype:\n"
    "from_file(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_serialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_serialize" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->serialize();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_serialize'.\n"
    "  Prototype:\n"
    "serialize(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_deserialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "Sparsity_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sparsity_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    try {
      result = casadi::Sparsity::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_deserialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Sparsity::deserialize((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_serialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::SerializingStream *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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_serialize" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sparsity_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sparsity_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::Sparsity const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_serialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_serialize",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_serialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_casadi__SerializingStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Sparsity_serialize__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_serialize'.\n"
    "  Possible prototypes are:\n"
    "    serialize(self)\n"
    "    serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_deserialize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sparsity_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Sparsity::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_deserialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_deserialize",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_deserialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DeserializingStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_deserialize__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_Sparsity_deserialize__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_deserialize'.\n"
    "  Possible prototypes are:\n"
    "    deserialize(std::istream &)\n"
    "    deserialize(casadi::DeserializingStream &)\n"
    "    deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_row" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_row'.\n"
    "  Prototype:\n"
    "row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_colind__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_colind" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_colind();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_colind'.\n"
    "  Prototype:\n"
    "colind(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_colind__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_colind" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->colind(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_colind'.\n"
    "  Prototype:\n"
    "colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_colind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_colind",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_colind__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Sparsity_colind__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_colind'.\n"
    "  Possible prototypes are:\n"
    "    colind(self)\n"
    "    colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_row" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->row(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_row'.\n"
    "  Prototype:\n"
    "row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_row(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_row",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sparsity_row__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Sparsity_row__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_row'.\n"
    "  Possible prototypes are:\n"
    "    row(self)\n"
    "    row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_col" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_col();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_col'.\n"
    "  Prototype:\n"
    "get_col(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_resize",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_resize" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_resize'.\n"
    "  Prototype:\n"
    "resize(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_add_nz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_add_nz",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_add_nz" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)(arg1)->add_nz(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_add_nz'.\n"
    "  Prototype:\n"
    "add_nz(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_nz" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->get_nz(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_has_nz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_has_nz",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_has_nz" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->has_nz(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_has_nz'.\n"
    "  Prototype:\n"
    "has_nz(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_nz" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_nz((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_nz__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_nz" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "int" "]" "'.");
  {
    try {
      ((casadi::Sparsity const *)arg1)->get_nz(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_get_nz",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_Sparsity_get_nz__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_Sparsity_get_nz__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_Sparsity_get_nz__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_get_nz'.\n"
    "  Possible prototypes are:\n"
    "    get_nz(self)\n"
    "    get_nz(self,int,int)\n"
    "    get_nz(self,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_lower" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_lower();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_lower'.\n"
    "  Prototype:\n"
    "get_lower(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_upper" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->get_upper();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_upper'.\n"
    "  Prototype:\n"
    "get_upper(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_ccs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_ccs" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      ((casadi::Sparsity const *)arg1)->get_ccs(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_ccs'.\n"
    "  Prototype:\n"
    "get_ccs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_crs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_crs" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      ((casadi::Sparsity const *)arg1)->get_crs(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_crs'.\n"
    "  Prototype:\n"
    "get_crs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_get_triplet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_get_triplet" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      ((casadi::Sparsity const *)arg1)->get_triplet(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_get_triplet'.\n"
    "  Prototype:\n"
    "get_triplet(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_sub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Sparsity result;
  
  arg4 = &m4;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_sub" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->sub((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_sub'.\n"
    "  Prototype:\n"
    "sub(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_sub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  casadi::Sparsity m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Sparsity result;
  
  arg4 = &m4;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_sub" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->sub((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(casadi::Sparsity const &)*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_sub'.\n"
    "  Prototype:\n"
    "sub(self,[int],Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_sub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_sub",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Sparsity_sub__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Sparsity_sub__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Sparsity_sub__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Sparsity_sub__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_sub'.\n"
    "  Possible prototypes are:\n"
    "    sub(self,[int],Sparsity,bool)\n"
    "    sub(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  arg2 = &m2;
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_transpose",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_transpose" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->transpose(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_transpose'.\n"
    "  Prototype:\n"
    "transpose(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_transpose",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_transpose" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_transpose((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_transpose'.\n"
    "  Prototype:\n"
    "is_transpose(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_reshape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_reshape",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_reshape" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_reshape((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_reshape'.\n"
    "  Prototype:\n"
    "is_reshape(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_combine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[4] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_combine",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_combine" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->combine((casadi::Sparsity const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_combine'.\n"
    "  Prototype:\n"
    "combine(self,Sparsity,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_unite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_unite",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_unite" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->unite((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_unite'.\n"
    "  Prototype:\n"
    "unite(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity___add__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity___add__" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->operator +((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity___add__'.\n"
    "  Prototype:\n"
    "__add__(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_intersect",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_intersect" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->intersect((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_intersect'.\n"
    "  Prototype:\n"
    "intersect(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity___mul__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity___mul__" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->operator *((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity___mul__'.\n"
    "  Prototype:\n"
    "__mul__(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_subset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_subset",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_subset" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_subset((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_subset'.\n"
    "  Prototype:\n"
    "is_subset(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_sparsity_cast_mod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity m3 ;
  PyObject *swig_obj[3] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_sparsity_cast_mod",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_sparsity_cast_mod" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->sparsity_cast_mod((casadi::Sparsity const &)*arg2,(casadi::Sparsity const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_sparsity_cast_mod'.\n"
    "  Prototype:\n"
    "sparsity_cast_mod(self,Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_pattern_inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_pattern_inverse" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->pattern_inverse();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_pattern_inverse'.\n"
    "  Prototype:\n"
    "pattern_inverse(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_enlarge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_enlarge",5,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_enlarge" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  if (swig_obj[5]) {
    if (!casadi::to_val(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlarge(arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_enlarge'.\n"
    "  Prototype:\n"
    "enlarge(self,int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_enlargeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_enlargeRows",3,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_enlargeRows" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlargeRows(arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_enlargeRows'.\n"
    "  Prototype:\n"
    "enlargeRows(self,int,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_enlargeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_enlargeColumns",3,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_enlargeColumns" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlargeColumns(arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_enlargeColumns'.\n"
    "  Prototype:\n"
    "enlargeColumns(self,int,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_makeDense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  arg2 = &m2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_makeDense" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->makeDense(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_makeDense'.\n"
    "  Prototype:\n"
    "makeDense(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_erase" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_erase" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Sparsity_erase",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Sparsity_erase__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_Sparsity_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Sparsity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Sparsity_erase__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Sparsity_erase__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Sparsity_erase'.\n"
    "  Possible prototypes are:\n"
    "    erase(self,[int],bool)\n"
    "    erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Sparsity_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_append",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_append" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->append((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_append'.\n"
    "  Prototype:\n"
    "append(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_appendColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_appendColumns",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_appendColumns" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->appendColumns((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_appendColumns'.\n"
    "  Prototype:\n"
    "appendColumns(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_scalar",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_scalar" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_scalar'.\n"
    "  Prototype:\n"
    "is_scalar(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_dense" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_dense();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_dense'.\n"
    "  Prototype:\n"
    "is_dense(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_row" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_row'.\n"
    "  Prototype:\n"
    "is_row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_column" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_column();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_column'.\n"
    "  Prototype:\n"
    "is_column(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_vector" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_vector'.\n"
    "  Prototype:\n"
    "is_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_diag" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_diag();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_diag'.\n"
    "  Prototype:\n"
    "is_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_square(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_square" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_square();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_square'.\n"
    "  Prototype:\n"
    "is_square(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_symmetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_symmetric" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_symmetric();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_symmetric'.\n"
    "  Prototype:\n"
    "is_symmetric(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_triu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_triu",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_triu" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_triu(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_triu'.\n"
    "  Prototype:\n"
    "is_triu(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_tril(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_tril",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_tril" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_tril(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_tril'.\n"
    "  Prototype:\n"
    "is_tril(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_singular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_singular" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_singular();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_singular'.\n"
    "  Prototype:\n"
    "is_singular(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_permutation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_permutation" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_permutation();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_permutation'.\n"
    "  Prototype:\n"
    "is_permutation(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_selection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_selection",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_selection" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_selection(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_selection'.\n"
    "  Prototype:\n"
    "is_selection(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_orthonormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_orthonormal",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_orthonormal" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_orthonormal(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_orthonormal'.\n"
    "  Prototype:\n"
    "is_orthonormal(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_orthonormal_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_orthonormal_rows",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_orthonormal_rows" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_orthonormal_rows(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_orthonormal_rows'.\n"
    "  Prototype:\n"
    "is_orthonormal_rows(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_is_orthonormal_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_is_orthonormal_columns",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_is_orthonormal_columns" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->is_orthonormal_columns(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_is_orthonormal_columns'.\n"
    "  Prototype:\n"
    "is_orthonormal_columns(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_rowsSequential(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_rowsSequential",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_rowsSequential" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Sparsity const *)arg1)->rowsSequential(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_rowsSequential'.\n"
    "  Prototype:\n"
    "rowsSequential(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_removeDuplicates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_removeDuplicates",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_removeDuplicates" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "int" "]" "'.");
  {
    try {
      (arg1)->removeDuplicates(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_removeDuplicates'.\n"
    "  Prototype:\n"
    "removeDuplicates(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_etree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_etree",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_etree" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->etree(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_etree'.\n"
    "  Prototype:\n"
    "etree(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_ldl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Sparsity result;
  
  arg2 = &m2;
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_ldl",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_ldl" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->ldl(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_ldl'.\n"
    "  Prototype:\n"
    "ldl(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_qr_sparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_qr_sparse",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_qr_sparse" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Sparsity const *)arg1)->qr_sparse(*arg2,*arg3,*arg4,*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_qr_sparse'.\n"
    "  Prototype:\n"
    "qr_sparse(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_dfs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< bool > m7 ;
  PyObject *swig_obj[7] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_dfs",7,7,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_dfs" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "bool" "]" "'.");
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->dfs(arg2,arg3,*arg4,*arg5,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg6,*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg7));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_dfs'.\n"
    "  Prototype:\n"
    "dfs(self,int,int,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_scc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_scc" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->scc(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_scc'.\n"
    "  Prototype:\n"
    "scc(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_btf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  arg6 = &m6;
  arg7 = &m7;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_btf" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Sparsity const *)arg1)->btf(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg6));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg7));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_btf'.\n"
    "  Prototype:\n"
    "btf(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_amd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_amd" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->amd();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_amd'.\n"
    "  Prototype:\n"
    "amd(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_find",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_find" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->find(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_find'.\n"
    "  Prototype:\n"
    "find(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_uni_coloring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi::Sparsity const &arg2_defvalue = casadi::Sparsity() ;
  casadi::Sparsity *arg2 = (casadi::Sparsity *) &arg2_defvalue ;
  casadi_int arg3 = (casadi_int) std::numeric_limits< casadi_int >::max() ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[3] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_uni_coloring",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_uni_coloring" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->uni_coloring((casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_uni_coloring'.\n"
    "  Prototype:\n"
    "uni_coloring(self,Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_star_coloring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) std::numeric_limits< casadi_int >::max() ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_star_coloring",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_star_coloring" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->star_coloring(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_star_coloring'.\n"
    "  Prototype:\n"
    "star_coloring(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_star_coloring2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) std::numeric_limits< casadi_int >::max() ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_star_coloring2",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_star_coloring2" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->star_coloring2(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_star_coloring2'.\n"
    "  Prototype:\n"
    "star_coloring2(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_largest_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_largest_first" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->largest_first();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_largest_first'.\n"
    "  Prototype:\n"
    "largest_first(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_pmult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) true ;
  bool arg4 = (bool) true ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  PyObject *swig_obj[5] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_pmult",2,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_pmult" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->pmult((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_pmult'.\n"
    "  Prototype:\n"
    "pmult(self,[int],bool,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_dim",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_dim" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->dim(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_dim'.\n"
    "  Prototype:\n"
    "dim(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_postfix_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_postfix_dim" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->postfix_dim();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_postfix_dim'.\n"
    "  Prototype:\n"
    "postfix_dim(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_repr_el(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_repr_el",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_repr_el" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->repr_el(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_repr_el'.\n"
    "  Prototype:\n"
    "repr_el(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_spy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::ostream &arg2_defvalue = casadi::uout() ;
  std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_spy" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      ((casadi::Sparsity const *)arg1)->spy(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_spy'.\n"
    "  Prototype:\n"
    "spy(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_spy_matlab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_spy_matlab",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_spy_matlab" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      ((casadi::Sparsity const *)arg1)->spy_matlab((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_spy_matlab'.\n"
    "  Prototype:\n"
    "spy_matlab(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_export_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  std::string *arg2 = 0 ;
  std::ostream &arg3_defvalue = casadi::uout() ;
  std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[3] ;
  
  arg3 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_export_code",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_export_code" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      ((casadi::Sparsity const *)arg1)->export_code((std::string const &)*arg2,*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_export_code'.\n"
    "  Prototype:\n"
    "export_code(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Sparsity::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'Sparsity_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Sparsity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_hash" "', argument " "1"" of type '" "casadi::Sparsity const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    try {
      result = ((casadi::Sparsity const *)arg1)->hash();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_hash'.\n"
    "  Prototype:\n"
    "hash(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_test_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObjectInternal *arg1 = (casadi::SharedObjectInternal *) 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_casadi__SharedObjectInternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sparsity_test_cast" "', argument " "1"" of type '" "casadi::SharedObjectInternal const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObjectInternal * >(argp1);
  {
    try {
      result = (bool)casadi::Sparsity::test_cast((casadi::SharedObjectInternal const *)arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_test_cast'.\n"
    "  Prototype:\n"
    "test_cast(casadi::SharedObjectInternal const *)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sparsity_kkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  bool arg3 = (bool) true ;
  bool arg4 = (bool) true ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  PyObject *swig_obj[4] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Sparsity_kkt",2,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::Sparsity::kkt((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Sparsity_kkt'.\n"
    "  Prototype:\n"
    "kkt(Sparsity,Sparsity,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sparsity__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    result = (casadi::Sparsity *)new casadi::Sparsity((casadi::Sparsity const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Sparsity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sparsity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Sparsity",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 1)) {
    int _v;
    if (argc <= 0) {
      return _wrap_new_Sparsity__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_new_Sparsity__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_new_Sparsity__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_new_Sparsity__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_new_Sparsity__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_Sparsity__SWIG_2(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_new_Sparsity__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Sparsity'.\n"
    "  Possible prototypes are:\n"
    "    Sparsity(int)\n"
    "    Sparsity((int,int))\n"
    "    Sparsity(Sparsity)\n"
    "    Sparsity(int,int)\n"
    "    Sparsity(int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = (casadi::Sparsity *) 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_casadi__Sparsity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sparsity" "', argument " "1"" of type '" "casadi::Sparsity *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Sparsity * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Sparsity'.\n"
    "  Prototype:\n"
    "Sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_hash_sparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::size_t result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::hash_sparsity(arg1,arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hash_sparsity'.\n"
    "  Prototype:\n"
    "hash_sparsity(int,int,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hash_sparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi_int *arg3 = (casadi_int *) 0 ;
  casadi_int *arg4 = (casadi_int *) 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  std::size_t result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_long_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "hash_sparsity" "', argument " "3"" of type '" "casadi_int const *""'"); 
  }
  arg3 = reinterpret_cast< casadi_int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_long_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "hash_sparsity" "', argument " "4"" of type '" "casadi_int const *""'"); 
  }
  arg4 = reinterpret_cast< casadi_int * >(argp4);
  {
    try {
      result = casadi::hash_sparsity(arg1,arg2,(long long const *)arg3,(long long const *)arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hash_sparsity'.\n"
    "  Prototype:\n"
    "hash_sparsity(int,int,casadi_int const *,casadi_int const *)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hash_sparsity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"hash_sparsity",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long_long, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_long_long, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_hash_sparsity__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            return _wrap_hash_sparsity__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'hash_sparsity'.\n"
    "  Possible prototypes are:\n"
    "    hash_sparsity(int,int,casadi_int const *,casadi_int const *)\n"
    "    hash_sparsity(int,int,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Slice_start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_start_get" "', argument " "1"" of type '" "casadi::Slice *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  result = (casadi_int) ((arg1)->start);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_start_get'.\n"
    "  Prototype:\n"
    "Slice_start_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_stop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_stop_get" "', argument " "1"" of type '" "casadi::Slice *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  result = (casadi_int) ((arg1)->stop);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_stop_get'.\n"
    "  Prototype:\n"
    "Slice_stop_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_step_get" "', argument " "1"" of type '" "casadi::Slice *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  result = (casadi_int) ((arg1)->step);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_step_get'.\n"
    "  Prototype:\n"
    "Slice_step_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Slice *)new casadi::Slice();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_Slice'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  bool arg2 = (bool) false ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (casadi::Slice *)new casadi::Slice(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (casadi::Slice *)new casadi::Slice(arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 = (int) 1 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 2) || (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_Slice" "', 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 '" "new_Slice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Slice" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  {
    try {
      result = (casadi::Slice *)new casadi::Slice(arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  casadi_int arg2 ;
  int arg3 = (int) 1 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 2) || (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_Slice" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Slice" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  {
    try {
      result = (casadi::Slice *)new casadi::Slice(arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  int arg2 ;
  int arg3 = (int) 1 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Slice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Slice" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  {
    try {
      result = (casadi::Slice *)new casadi::Slice(arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_all__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_all" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    try {
      result = ((casadi::Slice const *)arg1)->all();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_all'.\n"
    "  Prototype:\n"
    "all(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_all__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_all" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Slice const *)arg1)->all(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_all'.\n"
    "  Prototype:\n"
    "all(self,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_all__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi::Slice *arg2 = 0 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Slice m2 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_all" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Slice" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Slice const *)arg1)->all((casadi::Slice const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_all'.\n"
    "  Prototype:\n"
    "all(self,Slice,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_all(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Slice_all",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Slice, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Slice_all__SWIG_0(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Slice, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Slice_all__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_Slice_all__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Slice, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Slice **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_Slice_all__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Slice_all'.\n"
    "  Possible prototypes are:\n"
    "    all(self)\n"
    "    all(self,int,bool)\n"
    "    all(self,Slice,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Slice_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 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_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_size" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    try {
      result = ((casadi::Slice const *)arg1)->size();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_size'.\n"
    "  Prototype:\n"
    "size(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_is_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 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_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_is_empty" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    try {
      result = (bool)((casadi::Slice const *)arg1)->is_empty();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_is_empty'.\n"
    "  Prototype:\n"
    "is_empty(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_is_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice_is_scalar",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_is_scalar" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Slice const *)arg1)->is_scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_is_scalar'.\n"
    "  Prototype:\n"
    "is_scalar(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice_scalar",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_scalar" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Slice const *)arg1)->scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_scalar'.\n"
    "  Prototype:\n"
    "scalar(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi::Slice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Slice m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice___eq__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice___eq__" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Slice" "'.");
  {
    try {
      result = (bool)((casadi::Slice const *)arg1)->operator ==((casadi::Slice const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice___eq__'.\n"
    "  Prototype:\n"
    "__eq__(self,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi::Slice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Slice m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice___ne__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice___ne__" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Slice" "'.");
  {
    try {
      result = (bool)((casadi::Slice const *)arg1)->operator !=((casadi::Slice const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice___ne__'.\n"
    "  Prototype:\n"
    "__ne__(self,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi::Slice result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice_apply",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_apply" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Slice const *)arg1)->apply(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Slice" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_apply'.\n"
    "  Prototype:\n"
    "apply(self,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Slice result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice___sub__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice___sub__" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Slice const *)arg1)->operator -(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Slice" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice___sub__'.\n"
    "  Prototype:\n"
    "__sub__(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Slice result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice___mul__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice___mul__" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Slice const *)arg1)->operator *(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Slice" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice___mul__'.\n"
    "  Prototype:\n"
    "__mul__(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 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_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_type_name" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    try {
      result = ((casadi::Slice const *)arg1)->type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_type_name'.\n"
    "  Prototype:\n"
    "type_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"Slice_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_disp" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Slice const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_str" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Slice const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_info" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    try {
      result = ((casadi::Slice const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 0 ;
  casadi::SerializingStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Slice_serialize",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Slice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_serialize" "', argument " "1"" of type '" "casadi::Slice const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Slice_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Slice_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::Slice const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Slice_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Slice result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slice_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Slice_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Slice::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Slice" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Slice_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = 0 ;
  casadi::Slice m1 ;
  casadi::Slice *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Slice" "'.");
  {
    result = (casadi::Slice *)new casadi::Slice((casadi::Slice const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Slice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Slice'.\n"
    "  Prototype:\n"
    "Slice(Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Slice",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Slice__SWIG_0(self, argc, argv);
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_Slice__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_new_Slice__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Slice **>(0));
    if (_v) {
      return _wrap_new_Slice__SWIG_6(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_Slice__SWIG_3(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Slice__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_Slice__SWIG_4(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Slice__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_Slice__SWIG_5(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Slice__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_Slice__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_new_Slice__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Slice'.\n"
    "  Possible prototypes are:\n"
    "    Slice()\n"
    "    Slice(int,bool)\n"
    "    Slice(Slice)\n"
    "    Slice(int,int,int)\n"
    "    Slice(int,int,int)\n"
    "    Slice(int,int,int)\n"
    "    Slice(int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Slice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Slice *arg1 = (casadi::Slice *) 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_casadi__Slice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Slice" "', argument " "1"" of type '" "casadi::Slice *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Slice * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Slice'.\n"
    "  Prototype:\n"
    "Slice(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_to_slice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[2] ;
  casadi::Slice result;
  
  if (!SWIG_Python_UnpackTuple(args,"to_slice",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::to_slice((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Slice" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'to_slice'.\n"
    "  Prototype:\n"
    "to_slice([int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_slice2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::pair< casadi::Slice,casadi::Slice > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::to_slice2((std::vector< long long,std::allocator< long long > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< casadi::Slice,casadi::Slice >(static_cast< const std::pair< casadi::Slice,casadi::Slice >& >(result))), SWIGTYPE_p_std__pairT_casadi__Slice_casadi__Slice_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'to_slice2'.\n"
    "  Prototype:\n"
    "to_slice2([int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_slice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"is_slice",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)casadi::is_slice((std::vector< long long,std::allocator< long long > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'is_slice'.\n"
    "  Prototype:\n"
    "is_slice([int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_slice2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int > m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  {
    try {
      result = (bool)casadi::is_slice2((std::vector< long long,std::allocator< long long > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'is_slice2'.\n"
    "  Prototype:\n"
    "is_slice2([int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericMatrixCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericMatrixCommon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericMatrixCommon *)new casadi::GenericMatrixCommon();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenericMatrixCommon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericMatrixCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrixCommon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericMatrixCommon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GenericMatrixCommon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenericMatrixCommon" "', argument " "1"" of type '" "casadi::GenericMatrixCommon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericMatrixCommon" "', argument " "1"" of type '" "casadi::GenericMatrixCommon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrixCommon * >(argp1);
  {
    result = (casadi::GenericMatrixCommon *)new casadi::GenericMatrixCommon((casadi::GenericMatrixCommon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenericMatrixCommon'.\n"
    "  Prototype:\n"
    "GenericMatrixCommon(GenericMatrixCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericMatrixCommon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenericMatrixCommon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenericMatrixCommon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__GenericMatrixCommon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenericMatrixCommon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenericMatrixCommon'.\n"
    "  Possible prototypes are:\n"
    "    GenericMatrixCommon()\n"
    "    GenericMatrixCommon(GenericMatrixCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenericMatrixCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrixCommon *arg1 = (casadi::GenericMatrixCommon *) 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_casadi__GenericMatrixCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericMatrixCommon" "', argument " "1"" of type '" "casadi::GenericMatrixCommon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrixCommon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenericMatrixCommon'.\n"
    "  Prototype:\n"
    "GenericMatrixCommon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_index_interp1d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  double arg2 ;
  bool arg3 = (bool) false ;
  std::vector< double > m1 ;
  PyObject *swig_obj[3] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"index_interp1d",2,3,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = (double)casadi::index_interp1d((std::vector< double,std::allocator< double > > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'index_interp1d'.\n"
    "  Prototype:\n"
    "index_interp1d([float],float,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_nnz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_nnz" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->nnz();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_nnz'.\n"
    "  Prototype:\n"
    "nnz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_nnz_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_nnz_lower" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->nnz_lower();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_nnz_lower'.\n"
    "  Prototype:\n"
    "nnz_lower(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_nnz_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_nnz_upper" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->nnz_upper();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_nnz_upper'.\n"
    "  Prototype:\n"
    "nnz_upper(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_nnz_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_nnz_diag" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->nnz_diag();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_nnz_diag'.\n"
    "  Prototype:\n"
    "nnz_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_numel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_numel" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->numel();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_numel'.\n"
    "  Prototype:\n"
    "numel(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_size1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_size1" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->size1();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_size1'.\n"
    "  Prototype:\n"
    "size1(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_rows" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->rows();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_rows'.\n"
    "  Prototype:\n"
    "rows(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_size2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_size2" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->size2();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_size2'.\n"
    "  Prototype:\n"
    "size2(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_columns" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->columns();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_columns'.\n"
    "  Prototype:\n"
    "columns(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenDM_dim",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_dim" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->dim(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_dim'.\n"
    "  Prototype:\n"
    "dim(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->size();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_size'.\n"
    "  Prototype:\n"
    "size(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->size(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_size'.\n"
    "  Prototype:\n"
    "size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_size",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenDM_size__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenDM_size__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_size'.\n"
    "  Possible prototypes are:\n"
    "    size(self)\n"
    "    size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenDM_is_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenDM_is_empty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_empty" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_empty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_empty'.\n"
    "  Prototype:\n"
    "is_empty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_dense" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_dense();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_dense'.\n"
    "  Prototype:\n"
    "is_dense(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenDM_is_scalar",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_scalar" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_scalar'.\n"
    "  Prototype:\n"
    "is_scalar(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_square(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_square" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_square();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_square'.\n"
    "  Prototype:\n"
    "is_square(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_vector" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_vector'.\n"
    "  Prototype:\n"
    "is_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_row'.\n"
    "  Prototype:\n"
    "is_row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_column" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_column();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_column'.\n"
    "  Prototype:\n"
    "is_column(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_triu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_triu" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_triu();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_triu'.\n"
    "  Prototype:\n"
    "is_triu(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_is_tril(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_is_tril" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->is_tril();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_is_tril'.\n"
    "  Prototype:\n"
    "is_tril(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->get_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_row'.\n"
    "  Prototype:\n"
    "row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_colind__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->get_colind();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_colind'.\n"
    "  Prototype:\n"
    "colind(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->row(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_row'.\n"
    "  Prototype:\n"
    "row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_row(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_row",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenDM_row__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenDM_row__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_row'.\n"
    "  Possible prototypes are:\n"
    "    row(self)\n"
    "    row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenDM_colind__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->colind(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_colind'.\n"
    "  Prototype:\n"
    "colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_colind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_colind",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenDM_colind__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenDM_colind__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_colind'.\n"
    "  Possible prototypes are:\n"
    "    colind(self)\n"
    "    colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenDM_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDM_sparsity" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< double > > const *)arg1)->sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  std::string m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  std::string m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  std::string m1 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_sym(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_sym",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenDM_sym__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_GenDM_sym__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenDM_sym__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_GenDM_sym__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_GenDM_sym__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenDM_sym__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenDM_sym__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenDM_sym__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_GenDM_sym__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_sym'.\n"
    "  Possible prototypes are:\n"
    "    sym(str,int,int)\n"
    "    sym(str,(int,int))\n"
    "    sym(str,Sparsity)\n"
    "    sym(str,Sparsity,int)\n"
    "    sym(str,int,int,int)\n"
    "    sym(str,Sparsity,int,int)\n"
    "    sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenDM_zeros__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR zeros(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_zeros'.\n"
    "  Prototype:\n"
    "zeros(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_zeros__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR zeros((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_zeros'.\n"
    "  Prototype:\n"
    "zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_zeros__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR zeros((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_zeros'.\n"
    "  Prototype:\n"
    "zeros((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_zeros(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_zeros",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenDM_zeros__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenDM_zeros__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenDM_zeros__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenDM_zeros__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenDM_zeros__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_zeros'.\n"
    "  Possible prototypes are:\n"
    "    zeros(int,int)\n"
    "    zeros((int,int))\n"
    "    zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenDM_ones__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR ones(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_ones'.\n"
    "  Prototype:\n"
    "ones(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_ones__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR ones((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_ones'.\n"
    "  Prototype:\n"
    "ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_ones__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< double > >::SWIGTEMPLATEDISAMBIGUATOR ones((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenDM_ones'.\n"
    "  Prototype:\n"
    "ones((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenDM_ones(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenDM_ones",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenDM_ones__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenDM_ones__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenDM_ones__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenDM_ones__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenDM_ones__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenDM_ones'.\n"
    "  Possible prototypes are:\n"
    "    ones(int,int)\n"
    "    ones((int,int))\n"
    "    ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GenDM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericMatrix< casadi::Matrix< double > > *)new casadi::GenericMatrix< casadi::Matrix< double > >();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenDM'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenDM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericMatrix< casadi::Matrix< double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenDM" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenDM" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    result = (casadi::GenericMatrix< casadi::Matrix< double > > *)new casadi::GenericMatrix< casadi::Matrix< double > >((casadi::GenericMatrix< casadi::Matrix< double > > const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenDM'.\n"
    "  Prototype:\n"
    "GenDM(GenDM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenDM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenDM",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenDM__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenDM__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenDM'.\n"
    "  Possible prototypes are:\n"
    "    GenDM()\n"
    "    GenDM(GenDM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenDM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< double > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< double > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenDM" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< double > > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< double > > * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenDM'.\n"
    "  Prototype:\n"
    "GenDM(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_GenSX_nnz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_nnz" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->nnz();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_nnz'.\n"
    "  Prototype:\n"
    "nnz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_nnz_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_nnz_lower" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->nnz_lower();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_nnz_lower'.\n"
    "  Prototype:\n"
    "nnz_lower(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_nnz_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_nnz_upper" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->nnz_upper();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_nnz_upper'.\n"
    "  Prototype:\n"
    "nnz_upper(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_nnz_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_nnz_diag" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->nnz_diag();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_nnz_diag'.\n"
    "  Prototype:\n"
    "nnz_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_numel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_numel" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->numel();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_numel'.\n"
    "  Prototype:\n"
    "numel(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_size1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_size1" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->size1();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_size1'.\n"
    "  Prototype:\n"
    "size1(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_rows" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->rows();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_rows'.\n"
    "  Prototype:\n"
    "rows(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_size2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_size2" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->size2();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_size2'.\n"
    "  Prototype:\n"
    "size2(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_columns" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->columns();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_columns'.\n"
    "  Prototype:\n"
    "columns(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenSX_dim",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_dim" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->dim(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_dim'.\n"
    "  Prototype:\n"
    "dim(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->size();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_size'.\n"
    "  Prototype:\n"
    "size(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->size(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_size'.\n"
    "  Prototype:\n"
    "size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_size",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenSX_size__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenSX_size__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_size'.\n"
    "  Possible prototypes are:\n"
    "    size(self)\n"
    "    size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenSX_is_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenSX_is_empty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_empty" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_empty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_empty'.\n"
    "  Prototype:\n"
    "is_empty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_dense" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_dense();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_dense'.\n"
    "  Prototype:\n"
    "is_dense(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenSX_is_scalar",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_scalar" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_scalar'.\n"
    "  Prototype:\n"
    "is_scalar(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_square(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_square" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_square();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_square'.\n"
    "  Prototype:\n"
    "is_square(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_vector" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_vector'.\n"
    "  Prototype:\n"
    "is_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_row'.\n"
    "  Prototype:\n"
    "is_row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_column" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_column();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_column'.\n"
    "  Prototype:\n"
    "is_column(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_triu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_triu" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_triu();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_triu'.\n"
    "  Prototype:\n"
    "is_triu(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_is_tril(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_is_tril" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->is_tril();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_is_tril'.\n"
    "  Prototype:\n"
    "is_tril(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->get_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_row'.\n"
    "  Prototype:\n"
    "row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_colind__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->get_colind();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_colind'.\n"
    "  Prototype:\n"
    "colind(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->row(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_row'.\n"
    "  Prototype:\n"
    "row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_row(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_row",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenSX_row__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenSX_row__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_row'.\n"
    "  Possible prototypes are:\n"
    "    row(self)\n"
    "    row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenSX_colind__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->colind(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_colind'.\n"
    "  Prototype:\n"
    "colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_colind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_colind",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenSX_colind__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenSX_colind__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_colind'.\n"
    "  Possible prototypes are:\n"
    "    colind(self)\n"
    "    colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenSX_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenSX_sparsity" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const *)arg1)->sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  std::string m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  std::string m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  std::string m1 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_sym(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_sym",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenSX_sym__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_GenSX_sym__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenSX_sym__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_GenSX_sym__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_GenSX_sym__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenSX_sym__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenSX_sym__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenSX_sym__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_GenSX_sym__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_sym'.\n"
    "  Possible prototypes are:\n"
    "    sym(str,int,int)\n"
    "    sym(str,(int,int))\n"
    "    sym(str,Sparsity)\n"
    "    sym(str,Sparsity,int)\n"
    "    sym(str,int,int,int)\n"
    "    sym(str,Sparsity,int,int)\n"
    "    sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenSX_zeros__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR zeros(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_zeros'.\n"
    "  Prototype:\n"
    "zeros(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_zeros__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR zeros((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_zeros'.\n"
    "  Prototype:\n"
    "zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_zeros__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR zeros((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_zeros'.\n"
    "  Prototype:\n"
    "zeros((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_zeros(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_zeros",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenSX_zeros__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenSX_zeros__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenSX_zeros__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenSX_zeros__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenSX_zeros__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_zeros'.\n"
    "  Possible prototypes are:\n"
    "    zeros(int,int)\n"
    "    zeros((int,int))\n"
    "    zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenSX_ones__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR ones(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_ones'.\n"
    "  Prototype:\n"
    "ones(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_ones__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR ones((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_ones'.\n"
    "  Prototype:\n"
    "ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_ones__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >::SWIGTEMPLATEDISAMBIGUATOR ones((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenSX_ones'.\n"
    "  Prototype:\n"
    "ones((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenSX_ones(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenSX_ones",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenSX_ones__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenSX_ones__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenSX_ones__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenSX_ones__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenSX_ones__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenSX_ones'.\n"
    "  Possible prototypes are:\n"
    "    ones(int,int)\n"
    "    ones((int,int))\n"
    "    ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GenSX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *)new casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenSX'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenSX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenSX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenSX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    result = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *)new casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > >((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenSX'.\n"
    "  Prototype:\n"
    "GenSX(GenSX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenSX(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenSX",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenSX__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenSX__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenSX'.\n"
    "  Possible prototypes are:\n"
    "    GenSX()\n"
    "    GenSX(GenSX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenSX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *arg1 = (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) 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_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenSX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenSX'.\n"
    "  Prototype:\n"
    "GenSX(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_GenMX_nnz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_nnz" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->nnz();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_nnz'.\n"
    "  Prototype:\n"
    "nnz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_nnz_lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_nnz_lower" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->nnz_lower();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_nnz_lower'.\n"
    "  Prototype:\n"
    "nnz_lower(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_nnz_upper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_nnz_upper" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->nnz_upper();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_nnz_upper'.\n"
    "  Prototype:\n"
    "nnz_upper(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_nnz_diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_nnz_diag" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->nnz_diag();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_nnz_diag'.\n"
    "  Prototype:\n"
    "nnz_diag(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_numel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_numel" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->numel();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_numel'.\n"
    "  Prototype:\n"
    "numel(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_size1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_size1" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->size1();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_size1'.\n"
    "  Prototype:\n"
    "size1(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_rows" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->rows();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_rows'.\n"
    "  Prototype:\n"
    "rows(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_size2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_size2" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->size2();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_size2'.\n"
    "  Prototype:\n"
    "size2(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_columns" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->columns();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_columns'.\n"
    "  Prototype:\n"
    "columns(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenMX_dim",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_dim" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::GenericMatrix< casadi::MX > const *)arg1)->dim(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_dim'.\n"
    "  Prototype:\n"
    "dim(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::MX > const *)arg1)->size();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_size'.\n"
    "  Prototype:\n"
    "size(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_size" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->size(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_size'.\n"
    "  Prototype:\n"
    "size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_size",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenMX_size__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenMX_size__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_size'.\n"
    "  Possible prototypes are:\n"
    "    size(self)\n"
    "    size(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenMX_is_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenMX_is_empty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_empty" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_empty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_empty'.\n"
    "  Prototype:\n"
    "is_empty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_dense" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_dense();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_dense'.\n"
    "  Prototype:\n"
    "is_dense(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GenMX_is_scalar",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_scalar" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_scalar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_scalar'.\n"
    "  Prototype:\n"
    "is_scalar(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_square(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_square" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_square();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_square'.\n"
    "  Prototype:\n"
    "is_square(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_vector" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_vector'.\n"
    "  Prototype:\n"
    "is_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_row'.\n"
    "  Prototype:\n"
    "is_row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_column(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_column" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_column();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_column'.\n"
    "  Prototype:\n"
    "is_column(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_triu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_triu" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_triu();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_triu'.\n"
    "  Prototype:\n"
    "is_triu(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_is_tril(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_is_tril" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = (bool)((casadi::GenericMatrix< casadi::MX > const *)arg1)->is_tril();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_is_tril'.\n"
    "  Prototype:\n"
    "is_tril(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::MX > const *)arg1)->get_row();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_row'.\n"
    "  Prototype:\n"
    "row(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_colind__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::MX > const *)arg1)->get_colind();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_colind'.\n"
    "  Prototype:\n"
    "colind(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_row" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->row(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_row'.\n"
    "  Prototype:\n"
    "row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_row(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_row",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenMX_row__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenMX_row__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_row'.\n"
    "  Possible prototypes are:\n"
    "    row(self)\n"
    "    row(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenMX_colind__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_colind" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::GenericMatrix< casadi::MX > const *)arg1)->colind(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_colind'.\n"
    "  Prototype:\n"
    "colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_colind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_colind",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GenMX_colind__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenMX_colind__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_colind'.\n"
    "  Possible prototypes are:\n"
    "    colind(self)\n"
    "    colind(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenMX_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenMX_sparsity" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    try {
      result = ((casadi::GenericMatrix< casadi::MX > const *)arg1)->sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  std::string m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  std::string m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  std::string m1 ;
  casadi::Sparsity m2 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,(casadi::Sparsity const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  std::string m1 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR sym((std::string const &)*arg1,arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_sym'.\n"
    "  Prototype:\n"
    "sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_sym(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_sym",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenMX_sym__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_GenMX_sym__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenMX_sym__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_GenMX_sym__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_GenMX_sym__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_GenMX_sym__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenMX_sym__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_GenMX_sym__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_GenMX_sym__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_sym'.\n"
    "  Possible prototypes are:\n"
    "    sym(str,int,int)\n"
    "    sym(str,(int,int))\n"
    "    sym(str,Sparsity)\n"
    "    sym(str,Sparsity,int)\n"
    "    sym(str,int,int,int)\n"
    "    sym(str,Sparsity,int,int)\n"
    "    sym(str,int,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenMX_zeros__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR zeros(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_zeros'.\n"
    "  Prototype:\n"
    "zeros(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_zeros__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR zeros((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_zeros'.\n"
    "  Prototype:\n"
    "zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_zeros__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR zeros((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_zeros'.\n"
    "  Prototype:\n"
    "zeros((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_zeros(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_zeros",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenMX_zeros__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenMX_zeros__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenMX_zeros__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenMX_zeros__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenMX_zeros__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_zeros'.\n"
    "  Possible prototypes are:\n"
    "    zeros(int,int)\n"
    "    zeros((int,int))\n"
    "    zeros(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_GenMX_ones__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR ones(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_ones'.\n"
    "  Prototype:\n"
    "ones(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_ones__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR ones((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_ones'.\n"
    "  Prototype:\n"
    "ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_ones__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::GenericMatrix< casadi::MX >::SWIGTEMPLATEDISAMBIGUATOR ones((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'GenMX_ones'.\n"
    "  Prototype:\n"
    "ones((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GenMX_ones(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"GenMX_ones",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_GenMX_ones__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_GenMX_ones__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_GenMX_ones__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_GenMX_ones__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_GenMX_ones__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'GenMX_ones'.\n"
    "  Possible prototypes are:\n"
    "    ones(int,int)\n"
    "    ones((int,int))\n"
    "    ones(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GenMX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericMatrix< casadi::MX > *)new casadi::GenericMatrix< casadi::MX >();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenMX'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenMX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericMatrix< casadi::MX > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenMX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenMX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    result = (casadi::GenericMatrix< casadi::MX > *)new casadi::GenericMatrix< casadi::MX >((casadi::GenericMatrix< casadi::MX > const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenMX'.\n"
    "  Prototype:\n"
    "GenMX(GenMX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenMX(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenMX",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenMX__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__GenericMatrixT_casadi__MX_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenMX__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenMX'.\n"
    "  Possible prototypes are:\n"
    "    GenMX()\n"
    "    GenMX(GenMX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenMX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericMatrix< casadi::MX > *arg1 = (casadi::GenericMatrix< casadi::MX > *) 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_casadi__GenericMatrixT_casadi__MX_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenMX" "', argument " "1"" of type '" "casadi::GenericMatrix< casadi::MX > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericMatrix< casadi::MX > * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenMX'.\n"
    "  Prototype:\n"
    "GenMX(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_GenericExpressionCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::GenericExpressionCommon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::GenericExpressionCommon *)new casadi::GenericExpressionCommon();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericExpressionCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_GenericExpressionCommon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericExpressionCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::GenericExpressionCommon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericExpressionCommon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GenericExpressionCommon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenericExpressionCommon" "', argument " "1"" of type '" "casadi::GenericExpressionCommon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericExpressionCommon" "', argument " "1"" of type '" "casadi::GenericExpressionCommon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericExpressionCommon * >(argp1);
  {
    result = (casadi::GenericExpressionCommon *)new casadi::GenericExpressionCommon((casadi::GenericExpressionCommon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GenericExpressionCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_GenericExpressionCommon'.\n"
    "  Prototype:\n"
    "GenericExpressionCommon(GenericExpressionCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GenericExpressionCommon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GenericExpressionCommon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GenericExpressionCommon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__GenericExpressionCommon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GenericExpressionCommon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_GenericExpressionCommon'.\n"
    "  Possible prototypes are:\n"
    "    GenericExpressionCommon()\n"
    "    GenericExpressionCommon(GenericExpressionCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GenericExpressionCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GenericExpressionCommon *arg1 = (casadi::GenericExpressionCommon *) 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_casadi__GenericExpressionCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GenericExpressionCommon" "', argument " "1"" of type '" "casadi::GenericExpressionCommon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GenericExpressionCommon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GenericExpressionCommon'.\n"
    "  Prototype:\n"
    "GenericExpressionCommon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MatrixCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::MatrixCommon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::MatrixCommon *)new casadi::MatrixCommon();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_MatrixCommon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatrixCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MatrixCommon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MatrixCommon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__MatrixCommon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixCommon" "', argument " "1"" of type '" "casadi::MatrixCommon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixCommon" "', argument " "1"" of type '" "casadi::MatrixCommon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::MatrixCommon * >(argp1);
  {
    result = (casadi::MatrixCommon *)new casadi::MatrixCommon((casadi::MatrixCommon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MatrixCommon'.\n"
    "  Prototype:\n"
    "MatrixCommon(MatrixCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatrixCommon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MatrixCommon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MatrixCommon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__MatrixCommon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatrixCommon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_MatrixCommon'.\n"
    "  Possible prototypes are:\n"
    "    MatrixCommon()\n"
    "    MatrixCommon(MatrixCommon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MatrixCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MatrixCommon *arg1 = (casadi::MatrixCommon *) 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_casadi__MatrixCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatrixCommon" "', argument " "1"" of type '" "casadi::MatrixCommon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MatrixCommon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_MatrixCommon'.\n"
    "  Prototype:\n"
    "MatrixCommon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_DM'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((casadi::Sparsity const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(Sparsity,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg1 = 0 ;
  std::vector< std::vector< double > > m1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "[" "float" "]" "]" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM([[float]])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_has_nz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_has_nz",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_has_nz" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->has_nz(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_has_nz'.\n"
    "  Prototype:\n"
    "has_nz(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM___bool__" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->__nonzero__();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM___bool__'.\n"
    "  Prototype:\n"
    "__bool__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Sparsity m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_get",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_DM_get__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_DM_get__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_DM_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_DM_get__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_DM_get__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_DM_get__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_DM_get__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_get'.\n"
    "  Possible prototypes are:\n"
    "    get(self,bool,Sparsity)\n"
    "    get(self,bool,Slice)\n"
    "    get(self,bool,IM)\n"
    "    get(self,bool,Slice,Slice)\n"
    "    get(self,bool,Slice,IM)\n"
    "    get(self,bool,IM,Slice)\n"
    "    get(self,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Sparsity m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set'.\n"
    "  Prototype:\n"
    "set(self,DM,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_set",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Sparsity **>(0));
          if (_v) {
            return _wrap_DM_set__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_DM_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_DM_set__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_DM_set__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_DM_set__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_DM_set__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_DM_set__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_set'.\n"
    "  Possible prototypes are:\n"
    "    set(self,DM,bool,Sparsity)\n"
    "    set(self,DM,bool,Slice)\n"
    "    set(self,DM,bool,IM)\n"
    "    set(self,DM,bool,Slice,Slice)\n"
    "    set(self,DM,bool,Slice,IM)\n"
    "    set(self,DM,bool,IM,Slice)\n"
    "    set(self,DM,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_get_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get_nz" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get_nz(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_get_nz" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->get_nz(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_get_nz",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_DM_get_nz__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_DM_get_nz__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_get_nz'.\n"
    "  Possible prototypes are:\n"
    "    get_nz(self,bool,Slice)\n"
    "    get_nz(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_set_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set_nz" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set_nz((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,DM,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_set_nz" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set_nz((casadi::Matrix< double > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,DM,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_set_nz",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_DM_set_nz__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_DM_set_nz__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_set_nz'.\n"
    "  Possible prototypes are:\n"
    "    set_nz(self,DM,bool,Slice)\n"
    "    set_nz(self,DM,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM___pos__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM___pos__" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->operator +();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM___pos__'.\n"
    "  Prototype:\n"
    "__pos__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM___neg__" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->operator -();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM___neg__'.\n"
    "  Prototype:\n"
    "__neg__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_binary",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR binary(arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_binary'.\n"
    "  Prototype:\n"
    "binary(int,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_unary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_unary",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR unary(arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_unary'.\n"
    "  Prototype:\n"
    "unary(int,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_scalar_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_scalar_matrix",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR scalar_matrix(arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_scalar_matrix'.\n"
    "  Prototype:\n"
    "scalar_matrix(int,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_matrix_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_matrix_scalar",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR matrix_scalar(arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_matrix_scalar'.\n"
    "  Prototype:\n"
    "matrix_scalar(int,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_matrix_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_matrix_matrix",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR matrix_matrix(arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_matrix_matrix'.\n"
    "  Prototype:\n"
    "matrix_matrix(int,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_printme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_printme",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_printme" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->printme((casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_printme'.\n"
    "  Prototype:\n"
    "printme(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_set_max_depth",0,1,swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  {
    try {
      casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR set_max_depth(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_max_depth'.\n"
    "  Prototype:\n"
    "set_max_depth(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_get_max_depth",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR get_max_depth();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'DM_get_max_depth'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR get_input((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get_input'.\n"
    "  Prototype:\n"
    "get_input(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_get_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR get_free((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_get_free'.\n"
    "  Prototype:\n"
    "get_free(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'DM_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_print_split(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_print_split" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->print_split(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_print_split'.\n"
    "  Prototype:\n"
    "print_split(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"DM_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_disp" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_str" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_print_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_print_scalar" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->print_scalar(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_print_scalar'.\n"
    "  Prototype:\n"
    "print_scalar(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_print_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"DM_print_vector",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_print_vector" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->print_vector(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_print_vector'.\n"
    "  Prototype:\n"
    "print_vector(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_print_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"DM_print_dense",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_print_dense" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->print_dense(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_print_dense'.\n"
    "  Prototype:\n"
    "print_dense(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_print_sparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"DM_print_sparse",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_print_sparse" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->print_sparse(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_print_sparse'.\n"
    "  Prototype:\n"
    "print_sparse(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_clear" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_clear'.\n"
    "  Prototype:\n"
    "clear(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_resize",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_resize" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_resize'.\n"
    "  Prototype:\n"
    "resize(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_reserve" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      (arg1)->reserve(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_reserve'.\n"
    "  Prototype:\n"
    "reserve(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_reserve" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->reserve(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_reserve'.\n"
    "  Prototype:\n"
    "reserve(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_reserve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_reserve",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_DM_reserve__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_DM_reserve__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_reserve'.\n"
    "  Possible prototypes are:\n"
    "    reserve(self,int)\n"
    "    reserve(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_erase" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_erase" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_erase",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_DM_erase__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_DM_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_DM_erase__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_DM_erase__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_erase'.\n"
    "  Possible prototypes are:\n"
    "    erase(self,[int],bool)\n"
    "    erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_remove",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_remove" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      (arg1)->remove((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_remove'.\n"
    "  Prototype:\n"
    "remove(self,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_enlarge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_enlarge",5,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_enlarge" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  if (swig_obj[5]) {
    if (!casadi::to_val(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlarge(arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_enlarge'.\n"
    "  Prototype:\n"
    "enlarge(self,int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_sparsity" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->get_sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_triplet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_triplet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_triplet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  std::pair< casadi_int,casadi_int > *arg4 = 0 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< double > m3 ;
  std::pair< casadi_int,casadi_int > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(std::pair< long long,long long > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],DM,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_triplet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_triplet",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_DM_triplet__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::pair<casadi_int,casadi_int> **>(0));
          if (_v) {
            return _wrap_DM_triplet__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_DM_triplet__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_triplet'.\n"
    "  Possible prototypes are:\n"
    "    triplet([int],[int],DM)\n"
    "    triplet([int],[int],DM,(int,int))\n"
    "    triplet([int],[int],DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_inf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR inf((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_inf'.\n"
    "  Prototype:\n"
    "inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_inf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR inf(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_inf'.\n"
    "  Prototype:\n"
    "inf(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_inf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR inf((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_inf'.\n"
    "  Prototype:\n"
    "inf((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_inf",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_DM_inf__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_DM_inf__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_DM_inf__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_DM_inf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_DM_inf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_inf'.\n"
    "  Possible prototypes are:\n"
    "    inf(int,int)\n"
    "    inf((int,int))\n"
    "    inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_nan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR nan((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_nan'.\n"
    "  Prototype:\n"
    "nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_nan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR nan(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_nan'.\n"
    "  Prototype:\n"
    "nan(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_nan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR nan((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_nan'.\n"
    "  Prototype:\n"
    "nan((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_nan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_nan",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_DM_nan__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_DM_nan__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_DM_nan__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_DM_nan__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_DM_nan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_nan'.\n"
    "  Possible prototypes are:\n"
    "    nan(int,int)\n"
    "    nan((int,int))\n"
    "    nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR eye(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_eye'.\n"
    "  Prototype:\n"
    "eye(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_element_hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_element_hash" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< double > const *)arg1)->element_hash();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_element_hash'.\n"
    "  Prototype:\n"
    "element_hash(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_regular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_regular" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_regular();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_regular'.\n"
    "  Prototype:\n"
    "is_regular(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_smooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_smooth" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_smooth();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_smooth'.\n"
    "  Prototype:\n"
    "is_smooth(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_leaf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_leaf" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_leaf();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_leaf'.\n"
    "  Prototype:\n"
    "is_leaf(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_commutative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_commutative" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_commutative();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_commutative'.\n"
    "  Prototype:\n"
    "is_commutative(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_symbolic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_symbolic" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_symbolic();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_symbolic'.\n"
    "  Prototype:\n"
    "is_symbolic(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_valid_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_valid_input" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_valid_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_valid_input'.\n"
    "  Prototype:\n"
    "is_valid_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_has_duplicates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_has_duplicates" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->has_duplicates();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_has_duplicates'.\n"
    "  Prototype:\n"
    "has_duplicates(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_reset_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_reset_input" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->reset_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_reset_input'.\n"
    "  Prototype:\n"
    "reset_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_constant" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_constant();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_constant'.\n"
    "  Prototype:\n"
    "is_constant(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_integer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_integer" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_integer();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_integer'.\n"
    "  Prototype:\n"
    "is_integer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_zero" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_zero();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_zero'.\n"
    "  Prototype:\n"
    "is_zero(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_one" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_one'.\n"
    "  Prototype:\n"
    "is_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_minus_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_minus_one" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_minus_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_minus_one'.\n"
    "  Prototype:\n"
    "is_minus_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_eye" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_eye();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_eye'.\n"
    "  Prototype:\n"
    "is_eye(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_op" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< double > const *)arg1)->op();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_op'.\n"
    "  Prototype:\n"
    "op(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_is_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_is_op",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_is_op" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->is_op(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_is_op'.\n"
    "  Prototype:\n"
    "is_op(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_has_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_has_zeros" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< double > const *)arg1)->has_zeros();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_has_zeros'.\n"
    "  Prototype:\n"
    "has_zeros(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_nonzeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_nonzeros" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->get_nonzeros();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_nonzeros'.\n"
    "  Prototype:\n"
    "nonzeros(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_elements" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->get_elements();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_elements'.\n"
    "  Prototype:\n"
    "elements(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM___float__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM___float__" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (double)((casadi::Matrix< double > const *)arg1)->operator double();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM___float__'.\n"
    "  Prototype:\n"
    "__float__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM___int__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM___int__" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< double > const *)arg1)->operator casadi_int();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM___int__'.\n"
    "  Prototype:\n"
    "__int__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_name" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_name'.\n"
    "  Prototype:\n"
    "name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi_int arg2 = (casadi_int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_dep",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_dep" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->dep(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_dep'.\n"
    "  Prototype:\n"
    "dep(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_n_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_n_dep" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< double > const *)arg1)->n_dep();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_n_dep'.\n"
    "  Prototype:\n"
    "n_dep(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_precision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR set_precision(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_precision'.\n"
    "  Prototype:\n"
    "set_precision(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR set_width(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_width'.\n"
    "  Prototype:\n"
    "set_width(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_set_scientific(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "bool" "'.");
  {
    try {
      casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR set_scientific(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_set_scientific'.\n"
    "  Prototype:\n"
    "set_scientific(bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_rng(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR rng(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_rng'.\n"
    "  Prototype:\n"
    "rng(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_rand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR rand(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_rand'.\n"
    "  Prototype:\n"
    "rand(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_rand__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR rand((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_rand'.\n"
    "  Prototype:\n"
    "rand(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_rand__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR rand((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_rand'.\n"
    "  Prototype:\n"
    "rand((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_rand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_rand",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_DM_rand__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_DM_rand__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_DM_rand__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_DM_rand__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_DM_rand__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_rand'.\n"
    "  Possible prototypes are:\n"
    "    rand(int,int)\n"
    "    rand((int,int))\n"
    "    rand(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_export_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::ostream &arg3_defvalue = casadi::uout() ;
  std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[3] ;
  
  arg3 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"DM_export_code",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_export_code" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->export_code((std::string const &)*arg2,*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_export_code'.\n"
    "  Prototype:\n"
    "export_code(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_info" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_serialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_serialize" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< double > const *)arg1)->serialize();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_serialize'.\n"
    "  Prototype:\n"
    "serialize(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_deserialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "DM_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DM_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_deserialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR deserialize((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_serialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::SerializingStream *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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_serialize" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DM_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DM_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_serialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_serialize",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DM_serialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_casadi__SerializingStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DM_serialize__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_serialize'.\n"
    "  Possible prototypes are:\n"
    "    serialize(self)\n"
    "    serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_deserialize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DM_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DM_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_deserialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DM_deserialize",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DM_deserialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DeserializingStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DM_deserialize__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_DM_deserialize__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DM_deserialize'.\n"
    "  Possible prototypes are:\n"
    "    deserialize(std::istream &)\n"
    "    deserialize(casadi::DeserializingStream &)\n"
    "    deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_to_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  std::string *arg2 = 0 ;
  std::string const &arg3_defvalue = "" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_to_file",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_to_file" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      ((casadi::Matrix< double > const *)arg1)->to_file((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_to_file'.\n"
    "  Prototype:\n"
    "to_file(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_from_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string const &arg2_defvalue = "" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_from_file",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = casadi::Matrix< double >::SWIGTEMPLATEDISAMBIGUATOR from_file((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_from_file'.\n"
    "  Prototype:\n"
    "from_file(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::SXElem,std::allocator< casadi::SXElem > > *arg1 = 0 ;
  std::vector< casadi::SXElem > m1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SXElem" "]" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((std::vector< casadi::SXElem,std::allocator< casadi::SXElem > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM([SXElem])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = (casadi::Matrix< double > *)new casadi::Matrix< double >((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DM'.\n"
    "  Prototype:\n"
    "DM(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DM",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DM__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<std::vector<double> > **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_new_DM__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_new_DM__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_new_DM__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_DM'.\n"
    "  Possible prototypes are:\n"
    "    DM()\n"
    "    DM(Sparsity)\n"
    "    DM(float)\n"
    "    DM([[float]])\n"
    "    DM(DM)\n"
    "    DM([SXElem])\n"
    "    DM(SX)\n"
    "    DM(int,int)\n"
    "    DM(Sparsity,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DM_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DM_assign",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_assign" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      casadi_Matrix_Sl_double_Sg__assign(arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_assign'.\n"
    "  Prototype:\n"
    "assign(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_full(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_full" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (PyObject *)casadi_Matrix_Sl_double_Sg__full((casadi::Matrix< double > const *)arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_full'.\n"
    "  Prototype:\n"
    "full(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DM_sparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DM_sparse" "', argument " "1"" of type '" "casadi::Matrix< double > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    try {
      result = (PyObject *)casadi_Matrix_Sl_double_Sg__sparse((casadi::Matrix< double > const *)arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DM_sparse'.\n"
    "  Prototype:\n"
    "sparse(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = (casadi::Matrix< double > *) 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_casadi__MatrixT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DM" "', argument " "1"" of type '" "casadi::Matrix< double > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< double > * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_DM'.\n"
    "  Prototype:\n"
    "DM(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SXElem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::SXElem *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::SXElem *)new casadi::SXElem();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SXElem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_SXElem'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SXElem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SXElem *arg1 = 0 ;
  casadi::SXElem m1 ;
  casadi::SXElem *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SXElem" "'.");
  {
    result = (casadi::SXElem *)new casadi::SXElem((casadi::SXElem const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__SXElem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SXElem'.\n"
    "  Prototype:\n"
    "SXElem(SXElem)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SXElem(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SXElem",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SXElem__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::SXElem **>(0));
    if (_v) {
      return _wrap_new_SXElem__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_SXElem'.\n"
    "  Possible prototypes are:\n"
    "    SXElem()\n"
    "    SXElem(SXElem)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SXElem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SXElem *arg1 = (casadi::SXElem *) 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_casadi__SXElem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SXElem" "', argument " "1"" of type '" "casadi::SXElem *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SXElem * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SXElem'.\n"
    "  Prototype:\n"
    "SXElem(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_SX'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((casadi::Sparsity const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(Sparsity,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg1 = 0 ;
  std::vector< std::vector< double > > m1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "[" "float" "]" "]" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX([[float]])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_has_nz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_has_nz",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_has_nz" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->has_nz(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_has_nz'.\n"
    "  Prototype:\n"
    "has_nz(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX___bool__" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->__nonzero__();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX___bool__'.\n"
    "  Prototype:\n"
    "__bool__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Sparsity m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_get",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_SX_get__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_SX_get__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_SX_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_SX_get__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_SX_get__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_SX_get__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_SX_get__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_get'.\n"
    "  Possible prototypes are:\n"
    "    get(self,bool,Sparsity)\n"
    "    get(self,bool,Slice)\n"
    "    get(self,bool,IM)\n"
    "    get(self,bool,Slice,Slice)\n"
    "    get(self,bool,Slice,IM)\n"
    "    get(self,bool,IM,Slice)\n"
    "    get(self,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Sparsity m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set'.\n"
    "  Prototype:\n"
    "set(self,SX,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_set",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Sparsity **>(0));
          if (_v) {
            return _wrap_SX_set__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_SX_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_SX_set__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_SX_set__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_SX_set__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_SX_set__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_SX_set__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_set'.\n"
    "  Possible prototypes are:\n"
    "    set(self,SX,bool,Sparsity)\n"
    "    set(self,SX,bool,Slice)\n"
    "    set(self,SX,bool,IM)\n"
    "    set(self,SX,bool,Slice,Slice)\n"
    "    set(self,SX,bool,Slice,IM)\n"
    "    set(self,SX,bool,IM,Slice)\n"
    "    set(self,SX,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_get_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get_nz" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_nz(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_get_nz" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_nz(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_get_nz",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_SX_get_nz__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_SX_get_nz__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_get_nz'.\n"
    "  Possible prototypes are:\n"
    "    get_nz(self,bool,Slice)\n"
    "    get_nz(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_set_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set_nz" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set_nz((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,SX,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_set_nz" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set_nz((casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,SX,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_set_nz",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_SX_set_nz__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_SX_set_nz__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_set_nz'.\n"
    "  Possible prototypes are:\n"
    "    set_nz(self,SX,bool,Slice)\n"
    "    set_nz(self,SX,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX___pos__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX___pos__" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->operator +();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX___pos__'.\n"
    "  Prototype:\n"
    "__pos__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX___neg__" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->operator -();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX___neg__'.\n"
    "  Prototype:\n"
    "__neg__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_binary",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR binary(arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_binary'.\n"
    "  Prototype:\n"
    "binary(int,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_unary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_unary",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR unary(arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_unary'.\n"
    "  Prototype:\n"
    "unary(int,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_scalar_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_scalar_matrix",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR scalar_matrix(arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_scalar_matrix'.\n"
    "  Prototype:\n"
    "scalar_matrix(int,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_matrix_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_matrix_scalar",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR matrix_scalar(arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_matrix_scalar'.\n"
    "  Prototype:\n"
    "matrix_scalar(int,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_matrix_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_matrix_matrix",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR matrix_matrix(arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_matrix_matrix'.\n"
    "  Prototype:\n"
    "matrix_matrix(int,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_printme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_printme",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_printme" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->printme((casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_printme'.\n"
    "  Prototype:\n"
    "printme(self,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_set_max_depth",0,1,swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  {
    try {
      casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR set_max_depth(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_max_depth'.\n"
    "  Prototype:\n"
    "set_max_depth(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_get_max_depth",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR get_max_depth();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'SX_get_max_depth'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR get_input((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get_input'.\n"
    "  Prototype:\n"
    "get_input(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_get_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR get_free((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_get_free'.\n"
    "  Prototype:\n"
    "get_free(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'SX_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_print_split(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_print_split" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->print_split(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_print_split'.\n"
    "  Prototype:\n"
    "print_split(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SX_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_disp" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_str" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_print_scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_print_scalar" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->print_scalar(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_print_scalar'.\n"
    "  Prototype:\n"
    "print_scalar(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_print_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SX_print_vector",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_print_vector" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->print_vector(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_print_vector'.\n"
    "  Prototype:\n"
    "print_vector(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_print_dense(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SX_print_dense",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_print_dense" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->print_dense(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_print_dense'.\n"
    "  Prototype:\n"
    "print_dense(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_print_sparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SX_print_sparse",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_print_sparse" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->print_sparse(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_print_sparse'.\n"
    "  Prototype:\n"
    "print_sparse(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_clear" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_clear'.\n"
    "  Prototype:\n"
    "clear(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_resize",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_resize" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_resize'.\n"
    "  Prototype:\n"
    "resize(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_reserve" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      (arg1)->reserve(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_reserve'.\n"
    "  Prototype:\n"
    "reserve(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_reserve" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->reserve(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_reserve'.\n"
    "  Prototype:\n"
    "reserve(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_reserve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_reserve",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_SX_reserve__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_SX_reserve__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_reserve'.\n"
    "  Possible prototypes are:\n"
    "    reserve(self,int)\n"
    "    reserve(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_erase" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_erase" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_erase",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_SX_erase__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_SX_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_SX_erase__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_SX_erase__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_erase'.\n"
    "  Possible prototypes are:\n"
    "    erase(self,[int],bool)\n"
    "    erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_remove",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_remove" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      (arg1)->remove((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_remove'.\n"
    "  Prototype:\n"
    "remove(self,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_enlarge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_enlarge",5,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_enlarge" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  if (swig_obj[5]) {
    if (!casadi::to_val(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlarge(arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_enlarge'.\n"
    "  Prototype:\n"
    "enlarge(self,int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_sparsity" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_triplet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_triplet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_triplet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  std::pair< casadi_int,casadi_int > *arg4 = 0 ;
  std::vector< casadi_int > m1 ;
  std::vector< casadi_int > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::pair< casadi_int,casadi_int > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "int" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR triplet((std::vector< long long,std::allocator< long long > > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(std::pair< long long,long long > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_triplet'.\n"
    "  Prototype:\n"
    "triplet([int],[int],SX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_triplet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_triplet",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_SX_triplet__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::pair<casadi_int,casadi_int> **>(0));
          if (_v) {
            return _wrap_SX_triplet__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi_int> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_SX_triplet__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_triplet'.\n"
    "  Possible prototypes are:\n"
    "    triplet([int],[int],SX)\n"
    "    triplet([int],[int],SX,(int,int))\n"
    "    triplet([int],[int],SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_inf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR inf((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_inf'.\n"
    "  Prototype:\n"
    "inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_inf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR inf(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_inf'.\n"
    "  Prototype:\n"
    "inf(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_inf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR inf((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_inf'.\n"
    "  Prototype:\n"
    "inf((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_inf",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_SX_inf__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_SX_inf__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_SX_inf__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_SX_inf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_SX_inf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_inf'.\n"
    "  Possible prototypes are:\n"
    "    inf(int,int)\n"
    "    inf((int,int))\n"
    "    inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_nan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR nan((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_nan'.\n"
    "  Prototype:\n"
    "nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_nan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR nan(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_nan'.\n"
    "  Prototype:\n"
    "nan(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_nan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR nan((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_nan'.\n"
    "  Prototype:\n"
    "nan((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_nan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_nan",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_SX_nan__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_SX_nan__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_SX_nan__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_SX_nan__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_SX_nan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_nan'.\n"
    "  Possible prototypes are:\n"
    "    nan(int,int)\n"
    "    nan((int,int))\n"
    "    nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR eye(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_eye'.\n"
    "  Prototype:\n"
    "eye(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_element_hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_element_hash" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< casadi::SXElem > const *)arg1)->element_hash();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_element_hash'.\n"
    "  Prototype:\n"
    "element_hash(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_regular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_regular" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_regular();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_regular'.\n"
    "  Prototype:\n"
    "is_regular(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_smooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_smooth" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_smooth();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_smooth'.\n"
    "  Prototype:\n"
    "is_smooth(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_leaf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_leaf" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_leaf();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_leaf'.\n"
    "  Prototype:\n"
    "is_leaf(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_commutative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_commutative" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_commutative();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_commutative'.\n"
    "  Prototype:\n"
    "is_commutative(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_symbolic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_symbolic" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_symbolic();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_symbolic'.\n"
    "  Prototype:\n"
    "is_symbolic(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_valid_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_valid_input" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_valid_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_valid_input'.\n"
    "  Prototype:\n"
    "is_valid_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_has_duplicates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_has_duplicates" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->has_duplicates();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_has_duplicates'.\n"
    "  Prototype:\n"
    "has_duplicates(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_reset_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_reset_input" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->reset_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_reset_input'.\n"
    "  Prototype:\n"
    "reset_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_constant" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_constant();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_constant'.\n"
    "  Prototype:\n"
    "is_constant(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_integer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_integer" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_integer();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_integer'.\n"
    "  Prototype:\n"
    "is_integer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_zero" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_zero();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_zero'.\n"
    "  Prototype:\n"
    "is_zero(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_one" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_one'.\n"
    "  Prototype:\n"
    "is_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_minus_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_minus_one" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_minus_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_minus_one'.\n"
    "  Prototype:\n"
    "is_minus_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_eye" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_eye();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_eye'.\n"
    "  Prototype:\n"
    "is_eye(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_op" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< casadi::SXElem > const *)arg1)->op();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_op'.\n"
    "  Prototype:\n"
    "op(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_is_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_is_op",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_is_op" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->is_op(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_is_op'.\n"
    "  Prototype:\n"
    "is_op(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_has_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_has_zeros" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (bool)((casadi::Matrix< casadi::SXElem > const *)arg1)->has_zeros();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_has_zeros'.\n"
    "  Prototype:\n"
    "has_zeros(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_nonzeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::SXElem,std::allocator< casadi::SXElem > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_nonzeros" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_nonzeros();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SXElem" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_nonzeros'.\n"
    "  Prototype:\n"
    "nonzeros(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::SXElem,std::allocator< casadi::SXElem > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_elements" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->get_elements();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SXElem" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_elements'.\n"
    "  Prototype:\n"
    "elements(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX___float__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX___float__" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (double)((casadi::Matrix< casadi::SXElem > const *)arg1)->operator double();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX___float__'.\n"
    "  Prototype:\n"
    "__float__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX___int__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX___int__" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< casadi::SXElem > const *)arg1)->operator casadi_int();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX___int__'.\n"
    "  Prototype:\n"
    "__int__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_name" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_name'.\n"
    "  Prototype:\n"
    "name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi_int arg2 = (casadi_int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_dep",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_dep" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->dep(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_dep'.\n"
    "  Prototype:\n"
    "dep(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_n_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_n_dep" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Matrix< casadi::SXElem > const *)arg1)->n_dep();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_n_dep'.\n"
    "  Prototype:\n"
    "n_dep(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_precision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR set_precision(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_precision'.\n"
    "  Prototype:\n"
    "set_precision(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR set_width(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_width'.\n"
    "  Prototype:\n"
    "set_width(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_set_scientific(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "bool" "'.");
  {
    try {
      casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR set_scientific(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_set_scientific'.\n"
    "  Prototype:\n"
    "set_scientific(bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_rng(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR rng(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_rng'.\n"
    "  Prototype:\n"
    "rng(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_rand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR rand(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_rand'.\n"
    "  Prototype:\n"
    "rand(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_rand__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR rand((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_rand'.\n"
    "  Prototype:\n"
    "rand(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_rand__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR rand((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_rand'.\n"
    "  Prototype:\n"
    "rand((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_rand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_rand",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_SX_rand__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_SX_rand__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_SX_rand__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_SX_rand__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_SX_rand__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_rand'.\n"
    "  Possible prototypes are:\n"
    "    rand(int,int)\n"
    "    rand((int,int))\n"
    "    rand(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_export_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::string *arg2 = 0 ;
  std::ostream &arg3_defvalue = casadi::uout() ;
  std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[3] ;
  
  arg3 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"SX_export_code",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_export_code" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->export_code((std::string const &)*arg2,*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_export_code'.\n"
    "  Prototype:\n"
    "export_code(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_info" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_serialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_serialize" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    try {
      result = ((casadi::Matrix< casadi::SXElem > const *)arg1)->serialize();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_serialize'.\n"
    "  Prototype:\n"
    "serialize(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_deserialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "SX_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SX_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_deserialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR deserialize((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_serialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  casadi::SerializingStream *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_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_serialize" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SX_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SX_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_serialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_serialize",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SX_serialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_casadi__SerializingStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SX_serialize__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_serialize'.\n"
    "  Possible prototypes are:\n"
    "    serialize(self)\n"
    "    serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_deserialize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SX_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SX_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_deserialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SX_deserialize",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SX_deserialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DeserializingStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SX_deserialize__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_SX_deserialize__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SX_deserialize'.\n"
    "  Possible prototypes are:\n"
    "    deserialize(std::istream &)\n"
    "    deserialize(casadi::DeserializingStream &)\n"
    "    deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SX_to_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 0 ;
  std::string *arg2 = 0 ;
  std::string const &arg3_defvalue = "" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_to_file",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SX_to_file" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      ((casadi::Matrix< casadi::SXElem > const *)arg1)->to_file((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_to_file'.\n"
    "  Prototype:\n"
    "to_file(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SX_from_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string const &arg2_defvalue = "" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::Matrix< double > result;
  
  if (!SWIG_Python_UnpackTuple(args,"SX_from_file",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = casadi::Matrix< casadi::SXElem >::SWIGTEMPLATEDISAMBIGUATOR from_file((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SX_from_file'.\n"
    "  Prototype:\n"
    "from_file(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  std::vector< double > m1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((std::vector< double,std::allocator< double > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX([float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< casadi::SXElem > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = (casadi::Matrix< casadi::SXElem > *)new casadi::Matrix< casadi::SXElem >((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_SX'.\n"
    "  Prototype:\n"
    "SX(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SX(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SX",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SX__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<std::vector<double> > **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<double> **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_new_SX__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_new_SX__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_new_SX__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_SX'.\n"
    "  Possible prototypes are:\n"
    "    SX()\n"
    "    SX(Sparsity)\n"
    "    SX(float)\n"
    "    SX([[float]])\n"
    "    SX([float])\n"
    "    SX(DM)\n"
    "    SX(SX)\n"
    "    SX(int,int)\n"
    "    SX(Sparsity,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = (casadi::Matrix< casadi::SXElem > *) 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_casadi__MatrixT_casadi__SXElem_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SX" "', argument " "1"" of type '" "casadi::Matrix< casadi::SXElem > *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Matrix< casadi::SXElem > * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SX'.\n"
    "  Prototype:\n"
    "SX(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_MX_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::MX::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'MX_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::MX *)new casadi::MX();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_MX'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi_int arg2 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX m2 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX((casadi::Sparsity const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(Sparsity,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Sparsity m1 ;
  std::string m2 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX((casadi::Sparsity const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(Sparsity,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = (casadi::MX *)new casadi::MX((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MX" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_MX'.\n"
    "  Prototype:\n"
    "MX(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX___bool__" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->__nonzero__();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX___bool__'.\n"
    "  Prototype:\n"
    "__bool__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_sparsity" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->get_sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_erase" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_erase" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->erase((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_erase'.\n"
    "  Prototype:\n"
    "erase(self,[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_erase",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_MX_erase__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_MX_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_MX_erase__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_MX_erase__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_erase'.\n"
    "  Possible prototypes are:\n"
    "    erase(self,[int],bool)\n"
    "    erase(self,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_enlarge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  bool arg6 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_enlarge",5,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_enlarge" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  if (swig_obj[5]) {
    if (!casadi::to_val(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->enlarge(arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_enlarge'.\n"
    "  Prototype:\n"
    "enlarge(self,int,int,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX___neg__" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->operator -();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX___neg__'.\n"
    "  Prototype:\n"
    "__neg__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi_int arg2 = (casadi_int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_dep",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_dep" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::MX const *)arg1)->dep(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_dep'.\n"
    "  Prototype:\n"
    "dep(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_n_out" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_n_out'.\n"
    "  Prototype:\n"
    "n_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_get_output",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_output" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::MX const *)arg1)->get_output(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_output'.\n"
    "  Prototype:\n"
    "get_output(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_n_dep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_n_dep" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->n_dep();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_n_dep'.\n"
    "  Prototype:\n"
    "n_dep(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_name" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_name'.\n"
    "  Prototype:\n"
    "name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX___float__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX___float__" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (double)((casadi::MX const *)arg1)->operator double();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX___float__'.\n"
    "  Prototype:\n"
    "__float__(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_to_DM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_to_DM" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->operator casadi::Matrix<double>();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_to_DM'.\n"
    "  Prototype:\n"
    "to_DM(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_symbolic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_symbolic" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_symbolic();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_symbolic'.\n"
    "  Prototype:\n"
    "is_symbolic(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_constant" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_constant();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_constant'.\n"
    "  Prototype:\n"
    "is_constant(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_call(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_call" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_call();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_call'.\n"
    "  Prototype:\n"
    "is_call(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_which_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_which_function" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->which_function();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_which_function'.\n"
    "  Prototype:\n"
    "which_function(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_output" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_output();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_output'.\n"
    "  Prototype:\n"
    "is_output(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_which_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_which_output" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->which_output();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_which_output'.\n"
    "  Prototype:\n"
    "which_output(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_is_op",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_op" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_op(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_op'.\n"
    "  Prototype:\n"
    "is_op(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_multiplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_multiplication" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_multiplication();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_multiplication'.\n"
    "  Prototype:\n"
    "is_multiplication(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_commutative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_commutative" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_commutative();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_commutative'.\n"
    "  Prototype:\n"
    "is_commutative(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_norm" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_norm();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_norm'.\n"
    "  Prototype:\n"
    "is_norm(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_valid_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_valid_input" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_valid_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_valid_input'.\n"
    "  Prototype:\n"
    "is_valid_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_n_primitives(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_n_primitives" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->n_primitives();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_n_primitives'.\n"
    "  Prototype:\n"
    "n_primitives(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_primitives(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_primitives" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->primitives();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_primitives'.\n"
    "  Prototype:\n"
    "primitives(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_split_primitives(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_split_primitives",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_split_primitives" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::MX const *)arg1)->split_primitives((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_split_primitives'.\n"
    "  Prototype:\n"
    "split_primitives(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_join_primitives(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_join_primitives",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_join_primitives" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = ((casadi::MX const *)arg1)->join_primitives((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_join_primitives'.\n"
    "  Prototype:\n"
    "join_primitives(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_has_duplicates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_has_duplicates" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->has_duplicates();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_has_duplicates'.\n"
    "  Prototype:\n"
    "has_duplicates(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_reset_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_reset_input" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      ((casadi::MX const *)arg1)->reset_input();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_reset_input'.\n"
    "  Prototype:\n"
    "reset_input(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_eye" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_eye();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_eye'.\n"
    "  Prototype:\n"
    "is_eye(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_zero" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_zero();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_zero'.\n"
    "  Prototype:\n"
    "is_zero(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_one" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_one'.\n"
    "  Prototype:\n"
    "is_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_minus_one(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_minus_one" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_minus_one();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_minus_one'.\n"
    "  Prototype:\n"
    "is_minus_one(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_transpose" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_transpose();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_transpose'.\n"
    "  Prototype:\n"
    "is_transpose(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_regular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_regular" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_regular();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_regular'.\n"
    "  Prototype:\n"
    "is_regular(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_binary" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_binary();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_binary'.\n"
    "  Prototype:\n"
    "is_binary(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_is_unary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 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_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_is_unary" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (bool)((casadi::MX const *)arg1)->is_unary();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_is_unary'.\n"
    "  Prototype:\n"
    "is_unary(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_op(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_op" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->op();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_op'.\n"
    "  Prototype:\n"
    "op(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_info" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::SerializingStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_serialize",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_serialize" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MX_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MX_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::MX const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MX_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::MX::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_temp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_temp" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::MX const *)arg1)->get_temp();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_temp'.\n"
    "  Prototype:\n"
    "get_temp(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_temp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_set_temp",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set_temp" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->set_temp(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_temp'.\n"
    "  Prototype:\n"
    "set_temp(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_binary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_binary",3,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::MX::binary(arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_binary'.\n"
    "  Prototype:\n"
    "binary(int,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_unary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_unary",2,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::MX::unary(arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_unary'.\n"
    "  Prototype:\n"
    "unary(int,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_inf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::MX::inf((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_inf'.\n"
    "  Prototype:\n"
    "inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_inf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::MX::inf(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_inf'.\n"
    "  Prototype:\n"
    "inf(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_inf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::MX::inf((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_inf'.\n"
    "  Prototype:\n"
    "inf((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_inf",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_MX_inf__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_MX_inf__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_MX_inf__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_MX_inf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_MX_inf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_inf'.\n"
    "  Possible prototypes are:\n"
    "    inf(int,int)\n"
    "    inf((int,int))\n"
    "    inf(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_nan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::MX::nan((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_nan'.\n"
    "  Prototype:\n"
    "nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_nan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX result;
  
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::MX::nan(arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_nan'.\n"
    "  Prototype:\n"
    "nan(int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_nan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< casadi_int,casadi_int > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::MX::nan((std::pair< long long,long long > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_nan'.\n"
    "  Prototype:\n"
    "nan((int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_nan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_nan",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v;
    if (argc <= 0) {
      return _wrap_MX_nan__SWIG_1(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_MX_nan__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_MX_nan__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::pair<casadi_int,casadi_int> **>(0));
    if (_v) {
      return _wrap_MX_nan__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_MX_nan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_nan'.\n"
    "  Possible prototypes are:\n"
    "    nan(int,int)\n"
    "    nan((int,int))\n"
    "    nan(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::MX::eye(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_eye'.\n"
    "  Prototype:\n"
    "eye(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Sparsity m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi_int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi_int arg4 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,int,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi_int arg4 ;
  casadi_int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::MX const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,MX,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::MX m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::MX const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,Slice,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get__SWIG_14(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  casadi::MX m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get(*arg2,arg3,(casadi::MX const &)*arg4,(casadi::MX const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get'.\n"
    "  Prototype:\n"
    "get(self,bool,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_get",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_MX_get__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_MX_get__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_MX_get__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_MX_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_MX_get__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_MX_get__SWIG_14(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_get'.\n"
    "  Possible prototypes are:\n"
    "    get(self,bool,int)\n"
    "    get(self,bool,Sparsity)\n"
    "    get(self,bool,Slice)\n"
    "    get(self,bool,IM)\n"
    "    get(self,bool,MX)\n"
    "    get(self,bool,int,int)\n"
    "    get(self,bool,int,Slice)\n"
    "    get(self,bool,Slice,int)\n"
    "    get(self,bool,Slice,Slice)\n"
    "    get(self,bool,Slice,IM)\n"
    "    get(self,bool,Slice,MX)\n"
    "    get(self,bool,IM,Slice)\n"
    "    get(self,bool,IM,IM)\n"
    "    get(self,bool,MX,Slice)\n"
    "    get(self,bool,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Sparsity *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Sparsity m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,Slice,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,Slice,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Slice m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,IM,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  casadi::Matrix< casadi_int > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  casadi::Matrix< casadi_int > m5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "IM" "'.");
  {
    try {
      (arg1)->set((casadi::MX const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4,(casadi::Matrix< casadi_int > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set'.\n"
    "  Prototype:\n"
    "set(self,MX,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_set",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Sparsity **>(0));
          if (_v) {
            return _wrap_MX_set__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_MX_set__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_MX_set__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_MX_set__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Slice **>(0));
            if (_v) {
              return _wrap_MX_set__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi_int> **>(0));
            if (_v) {
              return _wrap_MX_set__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_set'.\n"
    "  Possible prototypes are:\n"
    "    set(self,MX,bool,Sparsity)\n"
    "    set(self,MX,bool,Slice)\n"
    "    set(self,MX,bool,IM)\n"
    "    set(self,MX,bool,Slice,Slice)\n"
    "    set(self,MX,bool,Slice,IM)\n"
    "    set(self,MX,bool,IM,Slice)\n"
    "    set(self,MX,bool,IM,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  arg2 = &m2;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  casadi::Slice *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  casadi::Slice m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "Slice" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::MX const &)*arg4,(casadi::Slice const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,MX,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  casadi::MX m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::Slice const &)*arg4,(casadi::MX const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,Slice,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  casadi::MX m5 ;
  
  arg2 = &m2;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_get_nz" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "MX" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->get_nz(*arg2,arg3,(casadi::MX const &)*arg4,(casadi::MX const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_nz'.\n"
    "  Prototype:\n"
    "get_nz(self,bool,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_get_nz",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_MX_get_nz__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          return _wrap_MX_get_nz__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi_int> **>(0));
        if (_v) {
          return _wrap_MX_get_nz__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_MX_get_nz__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Slice **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_MX_get_nz__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_get_nz__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_MX_get_nz__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_get_nz'.\n"
    "  Possible prototypes are:\n"
    "    get_nz(self,bool,int)\n"
    "    get_nz(self,bool,Slice)\n"
    "    get_nz(self,bool,IM)\n"
    "    get_nz(self,bool,MX)\n"
    "    get_nz(self,bool,Slice,MX)\n"
    "    get_nz(self,bool,MX,Slice)\n"
    "    get_nz(self,bool,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_set_nz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Slice *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Slice m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set_nz" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Slice" "'.");
  {
    try {
      (arg1)->set_nz((casadi::MX const &)*arg2,arg3,(casadi::Slice const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,MX,bool,Slice)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_nz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::Matrix< casadi_int > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< casadi_int > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set_nz" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "IM" "'.");
  {
    try {
      (arg1)->set_nz((casadi::MX const &)*arg2,arg3,(casadi::Matrix< casadi_int > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,MX,bool,IM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_nz__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi::MX *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set_nz" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      (arg1)->set_nz((casadi::MX const &)*arg2,arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,MX,bool,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_nz__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  bool arg3 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_set_nz" "', argument " "1"" of type '" "casadi::MX *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      (arg1)->set_nz((casadi::MX const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_nz'.\n"
    "  Prototype:\n"
    "set_nz(self,MX,bool,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_nz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_set_nz",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_MX_set_nz__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Slice **>(0));
          if (_v) {
            return _wrap_MX_set_nz__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi_int> **>(0));
          if (_v) {
            return _wrap_MX_set_nz__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__MX, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_MX_set_nz__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_set_nz'.\n"
    "  Possible prototypes are:\n"
    "    set_nz(self,MX,bool,int)\n"
    "    set_nz(self,MX,bool,Slice)\n"
    "    set_nz(self,MX,bool,IM)\n"
    "    set_nz(self,MX,bool,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_einstein__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg9 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  std::vector< casadi_int > m9 ;
  casadi::MX result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  arg9 = &m9;
  if (!casadi::to_ptr(swig_obj[8], &arg9)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 9 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::MX::einstein((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8,(std::vector< long long,std::allocator< long long > > const &)*arg9);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_einstein'.\n"
    "  Prototype:\n"
    "einstein(MX,MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_einstein__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  casadi::MX result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::MX::einstein((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'MX_einstein'.\n"
    "  Prototype:\n"
    "einstein(MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_einstein(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"MX_einstein",0,9,argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    return _wrap_MX_einstein__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    _v = casadi::to_ptr(argv[8], static_cast< std::vector<casadi_int> **>(0));
                    if (_v) {
                      return _wrap_MX_einstein__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'MX_einstein'.\n"
    "  Possible prototypes are:\n"
    "    einstein(MX,MX,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(MX,MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_MX_bspline_dual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< double > m1 ;
  std::vector< std::vector< double > > m2 ;
  std::vector< casadi_int > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::DM result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_bspline_dual",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "[" "float" "]" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::MX::bspline_dual((std::vector< double,std::allocator< double > > const &)*arg1,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_bspline_dual'.\n"
    "  Prototype:\n"
    "bspline_dual([float],[[float]],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_interpn_linear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::MX > m1 ;
  casadi::MX m2 ;
  std::vector< casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_interpn_linear",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::MX::interpn_linear((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(casadi::MX const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_interpn_linear'.\n"
    "  Prototype:\n"
    "interpn_linear([MX],MX,[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_printme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_printme",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_printme" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::MX const *)arg1)->printme((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_printme'.\n"
    "  Prototype:\n"
    "printme(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_attachAssert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  casadi::MX *arg2 = 0 ;
  std::string const &arg3_defvalue = "" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_attachAssert",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_attachAssert" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      result = ((casadi::MX const *)arg1)->attachAssert((casadi::MX const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_attachAssert'.\n"
    "  Prototype:\n"
    "attachAssert(self,MX,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_monitor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_monitor",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_monitor" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::MX const *)arg1)->monitor((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_monitor'.\n"
    "  Prototype:\n"
    "monitor(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_mapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi_int > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_mapping" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  {
    try {
      result = ((casadi::MX const *)arg1)->mapping();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "IM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_mapping'.\n"
    "  Prototype:\n"
    "mapping(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_set_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 = (casadi_int) 1 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_set_max_depth",0,1,swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  }
  {
    try {
      casadi::MX::set_max_depth(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_set_max_depth'.\n"
    "  Prototype:\n"
    "set_max_depth(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_max_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"MX_get_max_depth",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::MX::get_max_depth();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'MX_get_max_depth'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_test_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObjectInternal *arg1 = (casadi::SharedObjectInternal *) 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_casadi__SharedObjectInternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_test_cast" "', argument " "1"" of type '" "casadi::SharedObjectInternal const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObjectInternal * >(argp1);
  {
    try {
      result = (bool)casadi::MX::test_cast((casadi::SharedObjectInternal const *)arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_test_cast'.\n"
    "  Prototype:\n"
    "test_cast(casadi::SharedObjectInternal const *)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::MX::get_input((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_input'.\n"
    "  Prototype:\n"
    "get_input(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_get_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = casadi::MX::get_free((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_get_free'.\n"
    "  Prototype:\n"
    "get_free(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MX_eval_mx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = (casadi::MX *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  PyObject *swig_obj[2] ;
  
  arg3 = &m3;
  if (!SWIG_Python_UnpackTuple(args,"MX_eval_mx",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MX_eval_mx" "', argument " "1"" of type '" "casadi::MX const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MX * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      ((casadi::MX const *)arg1)->eval_mx((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MX_eval_mx'.\n"
    "  Prototype:\n"
    "eval_mx(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    result = (casadi::MX *)new casadi::MX((casadi::MX const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MX'.\n"
    "  Prototype:\n"
    "MX(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MX(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MX",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MX__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_new_MX__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_new_MX__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_new_MX__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_new_MX__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_new_MX__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_new_MX__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_new_MX__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_MX'.\n"
    "  Possible prototypes are:\n"
    "    MX()\n"
    "    MX(Sparsity)\n"
    "    MX(float)\n"
    "    MX(DM)\n"
    "    MX(MX)\n"
    "    MX(int,int)\n"
    "    MX(Sparsity,MX)\n"
    "    MX(Sparsity,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


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

SWIGINTERN PyObject *_wrap_Function_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Function::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'Function_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Function *)new casadi::Function();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_Function'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg2 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "SX" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg2,(std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,[SX],[SX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg2 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "SX" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg2,(std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,[SX],[SX],[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::map< std::string,casadi::SX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::SX > > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::map< std::string,casadi::SX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::SX > > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,dict:SX,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,[MX],[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,[MX],[MX],[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::map< std::string,casadi::MX > m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Function *)new casadi::Function((std::string const &)*arg1,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(str,dict:MX,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::jit((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jit'.\n"
    "  Prototype:\n"
    "jit(str,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg5 = 0 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg6 = 0 ;
  casadi::Dict const &arg7_defvalue = casadi::Dict() ;
  casadi::Dict *arg7 = (casadi::Dict *) &arg7_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::vector< casadi::Sparsity > m5 ;
  std::vector< casadi::Sparsity > m6 ;
  std::map< std::string,casadi::GenericType > m7 ;
  casadi::Function result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "Sparsity" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "Sparsity" "]" "'.");
  if (swig_obj[6]) {
    arg7 = &m7;
    if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::jit((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg5,(std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg6,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jit'.\n"
    "  Prototype:\n"
    "jit(str,str,[str],[str],[Sparsity],[Sparsity],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_jit",0,7,argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_jit__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_Function_jit__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector< casadi::Sparsity> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector< casadi::Sparsity> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_Function_jit__SWIG_1(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< std::map<std::string,casadi::GenericType> **>(0));
                if (_v) {
                  return _wrap_Function_jit__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_jit'.\n"
    "  Possible prototypes are:\n"
    "    jit(str,str,[str],[str],dict)\n"
    "    jit(str,str,[str],[str],[Sparsity],[Sparsity],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Function" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Function'.\n"
    "  Prototype:\n"
    "Function(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_expand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_expand" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->expand();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_expand'.\n"
    "  Prototype:\n"
    "expand(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_expand__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_expand" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->expand((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_expand'.\n"
    "  Prototype:\n"
    "expand(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_expand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_expand",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_expand__SWIG_0(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_expand__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Function_expand__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_expand'.\n"
    "  Possible prototypes are:\n"
    "    expand(self)\n"
    "    expand(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_n_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_n_in'.\n"
    "  Prototype:\n"
    "n_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_n_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_n_out'.\n"
    "  Prototype:\n"
    "n_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size1_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size1_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size1_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size1_in'.\n"
    "  Prototype:\n"
    "size1_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size1_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size1_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size1_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size1_in'.\n"
    "  Prototype:\n"
    "size1_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size1_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size1_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size1_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size1_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size1_in'.\n"
    "  Possible prototypes are:\n"
    "    size1_in(self,int)\n"
    "    size1_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_size2_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size2_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size2_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size2_in'.\n"
    "  Prototype:\n"
    "size2_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size2_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size2_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size2_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size2_in'.\n"
    "  Prototype:\n"
    "size2_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size2_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size2_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size2_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size2_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size2_in'.\n"
    "  Possible prototypes are:\n"
    "    size2_in(self,int)\n"
    "    size2_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_size_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->size_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size_in'.\n"
    "  Prototype:\n"
    "size_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->size_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size_in'.\n"
    "  Prototype:\n"
    "size_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size_in'.\n"
    "  Possible prototypes are:\n"
    "    size_in(self,int)\n"
    "    size_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_size1_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size1_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size1_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size1_out'.\n"
    "  Prototype:\n"
    "size1_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size1_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size1_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size1_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size1_out'.\n"
    "  Prototype:\n"
    "size1_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size1_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size1_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size1_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size1_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size1_out'.\n"
    "  Possible prototypes are:\n"
    "    size1_out(self,int)\n"
    "    size1_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_size2_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size2_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size2_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size2_out'.\n"
    "  Prototype:\n"
    "size2_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size2_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size2_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->size2_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size2_out'.\n"
    "  Prototype:\n"
    "size2_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size2_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size2_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size2_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size2_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size2_out'.\n"
    "  Possible prototypes are:\n"
    "    size2_out(self,int)\n"
    "    size2_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_size_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->size_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size_out'.\n"
    "  Prototype:\n"
    "size_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::pair< casadi_int,casadi_int > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_size_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->size_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "(" "int" "," "int" ")" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_size_out'.\n"
    "  Prototype:\n"
    "size_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_size_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_size_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_size_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_size_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_size_out'.\n"
    "  Possible prototypes are:\n"
    "    size_out(self,int)\n"
    "    size_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_nnz_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_in'.\n"
    "  Prototype:\n"
    "nnz_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_in'.\n"
    "  Prototype:\n"
    "nnz_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_in__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_in'.\n"
    "  Prototype:\n"
    "nnz_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_nnz_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_nnz_in__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_nnz_in__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_nnz_in__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_nnz_in'.\n"
    "  Possible prototypes are:\n"
    "    nnz_in(self)\n"
    "    nnz_in(self,int)\n"
    "    nnz_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_nnz_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_out'.\n"
    "  Prototype:\n"
    "nnz_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_out'.\n"
    "  Prototype:\n"
    "nnz_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nnz_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->nnz_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nnz_out'.\n"
    "  Prototype:\n"
    "nnz_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nnz_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_nnz_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_nnz_out__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_nnz_out__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_nnz_out__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_nnz_out'.\n"
    "  Possible prototypes are:\n"
    "    nnz_out(self)\n"
    "    nnz_out(self,int)\n"
    "    nnz_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_numel_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_in'.\n"
    "  Prototype:\n"
    "numel_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_in'.\n"
    "  Prototype:\n"
    "numel_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_in__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_in'.\n"
    "  Prototype:\n"
    "numel_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_numel_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_numel_in__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_numel_in__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_numel_in__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_numel_in'.\n"
    "  Possible prototypes are:\n"
    "    numel_in(self)\n"
    "    numel_in(self,int)\n"
    "    numel_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_numel_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_out'.\n"
    "  Prototype:\n"
    "numel_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_out'.\n"
    "  Prototype:\n"
    "numel_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_numel_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->numel_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_numel_out'.\n"
    "  Prototype:\n"
    "numel_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_numel_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_numel_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_numel_out__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_numel_out__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_numel_out__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_numel_out'.\n"
    "  Possible prototypes are:\n"
    "    numel_out(self)\n"
    "    numel_out(self,int)\n"
    "    numel_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_name_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_name_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *) &((casadi::Function const *)arg1)->name_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_name_in'.\n"
    "  Prototype:\n"
    "name_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_name_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_name_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *) &((casadi::Function const *)arg1)->name_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_name_out'.\n"
    "  Prototype:\n"
    "name_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_name_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_name_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (std::string *) &((casadi::Function const *)arg1)->name_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_name_in'.\n"
    "  Prototype:\n"
    "name_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_name_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_name_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_name_in__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_name_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_name_in'.\n"
    "  Possible prototypes are:\n"
    "    name_in(self)\n"
    "    name_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_name_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_name_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (std::string *) &((casadi::Function const *)arg1)->name_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_name_out'.\n"
    "  Prototype:\n"
    "name_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_name_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_name_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_name_out__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_name_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_name_out'.\n"
    "  Possible prototypes are:\n"
    "    name_out(self)\n"
    "    name_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_index_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_index_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_index_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->index_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_index_in'.\n"
    "  Prototype:\n"
    "index_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_index_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_index_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_index_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->index_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_index_out'.\n"
    "  Prototype:\n"
    "index_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_default_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_default_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_default_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (double)((casadi::Function const *)arg1)->default_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_default_in'.\n"
    "  Prototype:\n"
    "default_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_max_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_max_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_max_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (double)((casadi::Function const *)arg1)->max_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_max_in'.\n"
    "  Prototype:\n"
    "max_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_min_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_min_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_min_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (double)((casadi::Function const *)arg1)->min_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_min_in'.\n"
    "  Prototype:\n"
    "min_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nominal_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nominal_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nominal_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nominal_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nominal_in'.\n"
    "  Prototype:\n"
    "nominal_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nominal_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nominal_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nominal_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nominal_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nominal_out'.\n"
    "  Prototype:\n"
    "nominal_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::Sparsity *) &((casadi::Function const *)arg1)->sparsity_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_in'.\n"
    "  Prototype:\n"
    "sparsity_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi::Sparsity *) &((casadi::Function const *)arg1)->sparsity_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_in'.\n"
    "  Prototype:\n"
    "sparsity_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_sparsity_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_sparsity_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_sparsity_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_sparsity_in'.\n"
    "  Possible prototypes are:\n"
    "    sparsity_in(self,int)\n"
    "    sparsity_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi::Sparsity *) &((casadi::Function const *)arg1)->sparsity_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_out'.\n"
    "  Prototype:\n"
    "sparsity_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Sparsity *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi::Sparsity *) &((casadi::Function const *)arg1)->sparsity_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_out'.\n"
    "  Prototype:\n"
    "sparsity_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_sparsity_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_sparsity_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_sparsity_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_sparsity_out'.\n"
    "  Possible prototypes are:\n"
    "    sparsity_out(self,int)\n"
    "    sparsity_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_is_diff_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->is_diff_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_is_diff_in'.\n"
    "  Prototype:\n"
    "is_diff_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_is_diff_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->is_diff_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_is_diff_out'.\n"
    "  Prototype:\n"
    "is_diff_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_is_diff_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->is_diff_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_is_diff_in'.\n"
    "  Prototype:\n"
    "is_diff_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_is_diff_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_is_diff_in__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_is_diff_in__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_is_diff_in'.\n"
    "  Possible prototypes are:\n"
    "    is_diff_in(self)\n"
    "    is_diff_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_is_diff_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->is_diff_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_is_diff_out'.\n"
    "  Prototype:\n"
    "is_diff_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_is_diff_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_is_diff_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_is_diff_out__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_is_diff_out__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_is_diff_out'.\n"
    "  Possible prototypes are:\n"
    "    is_diff_out(self)\n"
    "    is_diff_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_factory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Function::AuxOut const &arg5_defvalue = casadi::Function::AuxOut() ;
  casadi::Function::AuxOut *arg5 = (casadi::Function::AuxOut *) &arg5_defvalue ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,std::vector< std::string > > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  PyObject *swig_obj[6] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_factory",4,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_factory" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" ":" "[" "str" "]" "'.");
  }
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->factory((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Function::AuxOut const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_factory'.\n"
    "  Prototype:\n"
    "factory(self,str,[str],[str],dict:[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_oracle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_oracle" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->oracle();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_oracle'.\n"
    "  Prototype:\n"
    "oracle(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_wrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_wrap" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->wrap();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_wrap'.\n"
    "  Prototype:\n"
    "wrap(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_wrap_as_needed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::Dict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_wrap_as_needed",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_wrap_as_needed" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->wrap_as_needed((casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_wrap_as_needed'.\n"
    "  Prototype:\n"
    "wrap_as_needed(self,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_which_depends(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[5] ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_which_depends",3,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_which_depends" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->which_depends((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_which_depends'.\n"
    "  Prototype:\n"
    "which_depends(self,str,[str],int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_print_dimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::ostream &arg2_defvalue = casadi::uout() ;
  std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_print_dimensions" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      ((casadi::Function const *)arg1)->print_dimensions(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_print_dimensions'.\n"
    "  Prototype:\n"
    "print_dimensions(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_print_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::ostream &arg2_defvalue = casadi::uout() ;
  std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &casadi::uout();
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_print_options" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      ((casadi::Function const *)arg1)->print_options(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_print_options'.\n"
    "  Prototype:\n"
    "print_options(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_print_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::ostream &arg3_defvalue = casadi::uout() ;
  std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  arg3 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"Function_print_option",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_print_option" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      ((casadi::Function const *)arg1)->print_option((std::string const &)*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_print_option'.\n"
    "  Prototype:\n"
    "print_option(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_has_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_has_option",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_has_option" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->has_option((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_has_option'.\n"
    "  Prototype:\n"
    "has_option(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_change_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::GenericType *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::GenericType m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_change_option",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_change_option" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "GenericType" "'.");
  {
    try {
      (arg1)->change_option((std::string const &)*arg2,(casadi::GenericType const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_change_option'.\n"
    "  Prototype:\n"
    "change_option(self,str,GenericType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_uses_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_uses_output" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->uses_output();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_uses_output'.\n"
    "  Prototype:\n"
    "uses_output(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jacobian_old(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_jacobian_old",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_jacobian_old" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->jacobian_old(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jacobian_old'.\n"
    "  Prototype:\n"
    "jacobian_old(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_hessian_old(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_hessian_old",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_hessian_old" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->hessian_old(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_hessian_old'.\n"
    "  Prototype:\n"
    "hessian_old(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_jac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_jac" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->sparsity_jac(arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_jac'.\n"
    "  Prototype:\n"
    "sparsity_jac(self,int,int,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_jac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_jac" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->sparsity_jac((std::string const &)*arg2,arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_jac'.\n"
    "  Prototype:\n"
    "sparsity_jac(self,str,int,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_jac__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  std::string *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m3 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_jac" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->sparsity_jac(arg2,(std::string const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_jac'.\n"
    "  Prototype:\n"
    "sparsity_jac(self,int,str,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_jac__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sparsity_jac" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->sparsity_jac((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sparsity_jac'.\n"
    "  Prototype:\n"
    "sparsity_jac(self,str,str,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sparsity_jac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_sparsity_jac",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_sparsity_jac__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_sparsity_jac__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_sparsity_jac__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_Function_sparsity_jac__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_sparsity_jac__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_sparsity_jac__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_Function_sparsity_jac__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_sparsity_jac__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_sparsity_jac__SWIG_2(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_Function_sparsity_jac__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_sparsity_jac__SWIG_3(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_sparsity_jac__SWIG_3(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_Function_sparsity_jac__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_sparsity_jac'.\n"
    "  Possible prototypes are:\n"
    "    sparsity_jac(self,str,int,bool,bool)\n"
    "    sparsity_jac(self,int,int,bool,bool)\n"
    "    sparsity_jac(self,int,str,bool,bool)\n"
    "    sparsity_jac(self,str,str,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_jacobian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_jacobian" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->jacobian();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jacobian'.\n"
    "  Prototype:\n"
    "jacobian(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,[DM],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg2 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,[SX],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,[MX],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::DMDict *arg2 = 0 ;
  casadi::DMDict *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< double > > m2 ;
  std::map< std::string,casadi::Matrix< double > > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((casadi::DMDict const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,dict:DM,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::SXDict *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((casadi::SXDict const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,dict:SX,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::MXDict *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::MX > m2 ;
  std::map< std::string,casadi::MX > m3 ;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_call" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->call((casadi::MXDict const &)*arg2,*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_call'.\n"
    "  Prototype:\n"
    "call(self,dict:MX,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_call(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_call",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_3(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_3(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_4(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_4(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_5(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_5(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_call__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_call__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_call__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_call'.\n"
    "  Possible prototypes are:\n"
    "    call(self,dict:DM,bool,bool)\n"
    "    call(self,[DM],bool,bool)\n"
    "    call(self,[SX],bool,bool)\n"
    "    call(self,dict:SX,bool,bool)\n"
    "    call(self,dict:MX,bool,bool)\n"
    "    call(self,[MX],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_mapsum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::string const &arg3_defvalue = "serial" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_mapsum",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapsum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapsum((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapsum'.\n"
    "  Prototype:\n"
    "mapsum(self,[MX],str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapaccum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapaccum((std::string const &)*arg2,arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapaccum'.\n"
    "  Prototype:\n"
    "mapaccum(self,str,int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapaccum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapaccum((std::string const &)*arg2,arg3,arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapaccum'.\n"
    "  Prototype:\n"
    "mapaccum(self,str,int,int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapaccum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapaccum((std::string const &)*arg2,arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapaccum'.\n"
    "  Prototype:\n"
    "mapaccum(self,str,int,[int],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapaccum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapaccum((std::string const &)*arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapaccum'.\n"
    "  Prototype:\n"
    "mapaccum(self,str,int,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mapaccum" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->mapaccum(arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mapaccum'.\n"
    "  Prototype:\n"
    "mapaccum(self,int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mapaccum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_mapaccum",0,6,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_mapaccum__SWIG_4(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Function_mapaccum__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_mapaccum__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_Function_mapaccum__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_mapaccum__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_Function_mapaccum__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_Function_mapaccum__SWIG_3(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_Function_mapaccum__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_Function_mapaccum__SWIG_2(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_Function_mapaccum__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_mapaccum'.\n"
    "  Possible prototypes are:\n"
    "    mapaccum(self,int,dict)\n"
    "    mapaccum(self,str,int,dict)\n"
    "    mapaccum(self,str,int,int,dict)\n"
    "    mapaccum(self,str,int,[str],[str],dict)\n"
    "    mapaccum(self,str,int,[int],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_fold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_fold",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_fold" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->fold(arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_fold'.\n"
    "  Prototype:\n"
    "fold(self,int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  std::string const &arg3_defvalue = "serial" ;
  std::string *arg3 = (std::string *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_map" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->map(arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_map'.\n"
    "  Prototype:\n"
    "map(self,int,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  std::string *arg3 = 0 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m3 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_map" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->map(arg2,(std::string const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_map'.\n"
    "  Prototype:\n"
    "map(self,int,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi_int arg4 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  casadi::Dict const &arg7_defvalue = casadi::Dict() ;
  casadi::Dict *arg7 = (casadi::Dict *) &arg7_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::map< std::string,casadi::GenericType > m7 ;
  casadi::Function result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_map" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  if (swig_obj[6]) {
    arg7 = &m7;
    if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->map((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg6,(casadi::Dict const &)*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_map'.\n"
    "  Prototype:\n"
    "map(self,str,str,int,[int],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi_int arg4 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg6 = 0 ;
  casadi::Dict const &arg7_defvalue = casadi::Dict() ;
  casadi::Dict *arg7 = (casadi::Dict *) &arg7_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  std::vector< std::string > m5 ;
  std::vector< std::string > m6 ;
  std::map< std::string,casadi::GenericType > m7 ;
  casadi::Function result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_map" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "str" "]" "'.");
  if (swig_obj[6]) {
    arg7 = &m7;
    if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->map((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(std::vector< std::string,std::allocator< std::string > > const &)*arg6,(casadi::Dict const &)*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_map'.\n"
    "  Prototype:\n"
    "map(self,str,str,int,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  std::vector< bool,std::allocator< bool > > *arg3 = 0 ;
  std::vector< bool,std::allocator< bool > > const &arg4_defvalue = std::vector< bool >() ;
  std::vector< bool,std::allocator< bool > > *arg4 = (std::vector< bool,std::allocator< bool > > *) &arg4_defvalue ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool > m3 ;
  std::vector< bool > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_map" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "bool" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "bool" "]" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->map(arg2,(std::vector< bool,std::allocator< bool > > const &)*arg3,(std::vector< bool,std::allocator< bool > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_map'.\n"
    "  Prototype:\n"
    "map(self,int,[bool],[bool],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_map(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_map",0,7,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_map__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_Function_map__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<bool> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_map__SWIG_4(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<bool> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Function_map__SWIG_4(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_Function_map__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_Function_map__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<std::string> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_Function_map__SWIG_3(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< std::map<std::string,casadi::GenericType> **>(0));
                if (_v) {
                  return _wrap_Function_map__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_Function_map__SWIG_2(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< std::map<std::string,casadi::GenericType> **>(0));
                if (_v) {
                  return _wrap_Function_map__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_map'.\n"
    "  Possible prototypes are:\n"
    "    map(self,int,str)\n"
    "    map(self,int,[bool],[bool],dict)\n"
    "    map(self,int,str,int)\n"
    "    map(self,str,str,int,[str],[str],dict)\n"
    "    map(self,str,str,int,[int],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_slice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  PyObject *swig_obj[5] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_slice",4,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_slice" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->slice((std::string const &)*arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_slice'.\n"
    "  Prototype:\n"
    "slice(self,str,[int],[int],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_conditional__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::vector< casadi::Function > m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "Function" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::conditional((std::string const &)*arg1,(std::vector< casadi::Function,std::allocator< casadi::Function > > const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_conditional'.\n"
    "  Prototype:\n"
    "conditional(str,[Function],Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_conditional__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Function *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m1 ;
  casadi::Function m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Function" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::conditional((std::string const &)*arg1,(casadi::Function const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_conditional'.\n"
    "  Prototype:\n"
    "conditional(str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_conditional(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_conditional",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Function **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_conditional__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Function_conditional__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::Function> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_conditional__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_Function_conditional__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_conditional'.\n"
    "  Possible prototypes are:\n"
    "    conditional(str,Function,dict)\n"
    "    conditional(str,[Function],Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_bspline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi_int arg5 = (casadi_int) 1 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::vector< std::vector< double > > m2 ;
  std::vector< double > m3 ;
  std::vector< casadi_int > m4 ;
  std::map< std::string,casadi::GenericType > m6 ;
  PyObject *swig_obj[6] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_bspline",4,6,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "[" "float" "]" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  }
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::bspline((std::string const &)*arg1,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_bspline'.\n"
    "  Prototype:\n"
    "bspline(str,[[float]],[float],[int],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_if_else(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Function *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  casadi::Function m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_if_else",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Function" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::Function::if_else((std::string const &)*arg1,(casadi::Function const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_if_else'.\n"
    "  Prototype:\n"
    "if_else(str,Function,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_forward(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_forward",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_forward" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->forward(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_forward'.\n"
    "  Prototype:\n"
    "forward(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_reverse",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_reverse" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->reverse(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_reverse'.\n"
    "  Prototype:\n"
    "reverse(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jac_sparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_jac_sparsity" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = (std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *) &((casadi::Function const *)arg1)->jac_sparsity(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jac_sparsity'.\n"
    "  Prototype:\n"
    "jac_sparsity(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jac_sparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_jac_sparsity" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->jac_sparsity(arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_jac_sparsity'.\n"
    "  Prototype:\n"
    "jac_sparsity(self,int,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_jac_sparsity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_jac_sparsity",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_Function_jac_sparsity__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_Function_jac_sparsity__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_jac_sparsity__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Function_jac_sparsity__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_jac_sparsity'.\n"
    "  Possible prototypes are:\n"
    "    jac_sparsity(self,bool)\n"
    "    jac_sparsity(self,int,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_generate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->generate((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate'.\n"
    "  Prototype:\n"
    "generate(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m2 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->generate((casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate'.\n"
    "  Prototype:\n"
    "generate(self,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_generate",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_Function_generate__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_Function_generate__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_generate__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Function_generate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_generate'.\n"
    "  Possible prototypes are:\n"
    "    generate(self,dict)\n"
    "    generate(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_generate_dependencies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_generate_dependencies",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_dependencies" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->generate_dependencies((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_dependencies'.\n"
    "  Prototype:\n"
    "generate_dependencies(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_in" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "DM" "]" "'.");
  {
    try {
      (arg1)->generate_in((std::string const &)*arg2,(std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_in'.\n"
    "  Prototype:\n"
    "generate_in(self,str,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_in" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (arg1)->generate_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_in'.\n"
    "  Prototype:\n"
    "generate_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_generate_in",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_generate_in__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<double> > **>(0));
        if (_v) {
          return _wrap_Function_generate_in__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_generate_in'.\n"
    "  Possible prototypes are:\n"
    "    generate_in(self,str)\n"
    "    generate_in(self,str,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_generate_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_out" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "DM" "]" "'.");
  {
    try {
      (arg1)->generate_out((std::string const &)*arg2,(std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_out'.\n"
    "  Prototype:\n"
    "generate_out(self,str,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_out" "', argument " "1"" of type '" "casadi::Function *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (arg1)->generate_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_out'.\n"
    "  Prototype:\n"
    "generate_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_generate_out",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_generate_out__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<double> > **>(0));
        if (_v) {
          return _wrap_Function_generate_out__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_generate_out'.\n"
    "  Possible prototypes are:\n"
    "    generate_out(self,str)\n"
    "    generate_out(self,str,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_export_code__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_export_code" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->export_code((std::string const &)*arg2,(std::string const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_export_code'.\n"
    "  Prototype:\n"
    "export_code(self,str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_serialize",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_serialize" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->serialize((casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_save",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_save" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->save((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_save'.\n"
    "  Prototype:\n"
    "save(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_export_code__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_export_code" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->export_code((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_export_code'.\n"
    "  Prototype:\n"
    "export_code(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_export_code(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_export_code",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Function_export_code__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Function_export_code__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Function_export_code__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_Function_export_code__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_export_code'.\n"
    "  Possible prototypes are:\n"
    "    export_code(self,str,dict)\n"
    "    export_code(self,str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  int arg2 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Dict result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_stats",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_stats" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Function_stats" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->stats(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_stats'.\n"
    "  Prototype:\n"
    "stats(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::SX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_in'.\n"
    "  Prototype:\n"
    "sx_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::SX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_in'.\n"
    "  Prototype:\n"
    "sx_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_in__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_in'.\n"
    "  Prototype:\n"
    "sx_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_sx_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_sx_in__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_sx_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_sx_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_sx_in'.\n"
    "  Possible prototypes are:\n"
    "    sx_in(self)\n"
    "    sx_in(self,int)\n"
    "    sx_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_mx_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_in(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_in'.\n"
    "  Prototype:\n"
    "mx_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_in'.\n"
    "  Prototype:\n"
    "mx_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_in__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_in'.\n"
    "  Prototype:\n"
    "mx_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_mx_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_mx_in__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_mx_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_mx_in__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_mx_in'.\n"
    "  Possible prototypes are:\n"
    "    mx_in(self)\n"
    "    mx_in(self,int)\n"
    "    mx_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_sx_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::SX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_out'.\n"
    "  Prototype:\n"
    "sx_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::SX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_out'.\n"
    "  Prototype:\n"
    "sx_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sx_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sx_out'.\n"
    "  Prototype:\n"
    "sx_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sx_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_sx_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_sx_out__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_sx_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_sx_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_sx_out'.\n"
    "  Possible prototypes are:\n"
    "    sx_out(self)\n"
    "    sx_out(self,int)\n"
    "    sx_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_mx_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_out(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_out'.\n"
    "  Prototype:\n"
    "mx_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_out((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_out'.\n"
    "  Prototype:\n"
    "mx_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_mx_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->mx_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_mx_out'.\n"
    "  Prototype:\n"
    "mx_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_mx_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_mx_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_mx_out__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_Function_mx_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_mx_out__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_mx_out'.\n"
    "  Possible prototypes are:\n"
    "    mx_out(self)\n"
    "    mx_out(self,int)\n"
    "    mx_out(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_nz_from_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nz_from_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nz_from_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nz_from_in((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nz_from_in'.\n"
    "  Prototype:\n"
    "nz_from_in(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nz_from_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nz_from_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nz_from_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nz_from_out((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nz_from_out'.\n"
    "  Prototype:\n"
    "nz_from_out(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nz_to_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > m2 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nz_to_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nz_to_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "float" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nz_to_in((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nz_to_in'.\n"
    "  Prototype:\n"
    "nz_to_in(self,[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_nz_to_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > m2 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_nz_to_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_nz_to_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "float" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->nz_to_out((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_nz_to_out'.\n"
    "  Prototype:\n"
    "nz_to_out(self,[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  casadi::DMDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::DMDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< double > > m2 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "DM" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((casadi::DMDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,dict:DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  casadi::DMDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::DMDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< double > > m2 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "DM" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((casadi::DMDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,dict:DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  casadi::SXDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,[SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::SXDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((casadi::SXDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,dict:SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  casadi::SXDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((std::vector< casadi::SX,std::allocator< casadi::SX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,[SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::SXDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((casadi::SXDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,dict:SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  casadi::MXDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::MXDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::MX > m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_in((casadi::MXDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_in'.\n"
    "  Prototype:\n"
    "convert_in(self,dict:MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_convert_in",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_Function_convert_in__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_convert_in'.\n"
    "  Possible prototypes are:\n"
    "    convert_in(self,dict:DM)\n"
    "    convert_in(self,[DM])\n"
    "    convert_in(self,[SX])\n"
    "    convert_in(self,dict:SX)\n"
    "    convert_in(self,dict:MX)\n"
    "    convert_in(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  casadi::MXDict result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::MXDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::MX > m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_convert_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->convert_out((casadi::MXDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_convert_out'.\n"
    "  Prototype:\n"
    "convert_out(self,dict:MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_convert_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_convert_out",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_Function_convert_out__SWIG_4(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_convert_out'.\n"
    "  Possible prototypes are:\n"
    "    convert_out(self,dict:DM)\n"
    "    convert_out(self,[DM])\n"
    "    convert_out(self,[SX])\n"
    "    convert_out(self,dict:SX)\n"
    "    convert_out(self,dict:MX)\n"
    "    convert_out(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_has_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_has_free" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->has_free();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_has_free'.\n"
    "  Prototype:\n"
    "has_free(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_get_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_get_free" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->get_free();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_get_free'.\n"
    "  Prototype:\n"
    "get_free(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_free_sx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::SX,std::allocator< casadi::SX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_free_sx" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->free_sx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_free_sx'.\n"
    "  Prototype:\n"
    "free_sx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_free_mx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_free_mx" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->free_mx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_free_mx'.\n"
    "  Prototype:\n"
    "free_mx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_generate_lifted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi::Function *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function m2 ;
  casadi::Function m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_generate_lifted" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      ((casadi::Function const *)arg1)->generate_lifted(*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_generate_lifted'.\n"
    "  Prototype:\n"
    "generate_lifted(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_n_nodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_n_nodes" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->n_nodes();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_n_nodes'.\n"
    "  Prototype:\n"
    "n_nodes(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_n_instructions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_n_instructions" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->n_instructions();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_n_instructions'.\n"
    "  Prototype:\n"
    "n_instructions(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instruction_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_instruction_id",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instruction_id" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->instruction_id(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instruction_id'.\n"
    "  Prototype:\n"
    "instruction_id(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instruction_input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_instruction_input",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instruction_input" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->instruction_input(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instruction_input'.\n"
    "  Prototype:\n"
    "instruction_input(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instruction_constant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_instruction_constant",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instruction_constant" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = (double)((casadi::Function const *)arg1)->instruction_constant(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instruction_constant'.\n"
    "  Prototype:\n"
    "instruction_constant(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instruction_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_instruction_output",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instruction_output" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->instruction_output(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instruction_output'.\n"
    "  Prototype:\n"
    "instruction_output(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instruction_MX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_instruction_MX",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instruction_MX" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->instruction_MX(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instruction_MX'.\n"
    "  Prototype:\n"
    "instruction_MX(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_instructions_sx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::SX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_instructions_sx" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->instructions_sx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_instructions_sx'.\n"
    "  Prototype:\n"
    "instructions_sx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_has_spfwd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_has_spfwd" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->has_spfwd();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_has_spfwd'.\n"
    "  Prototype:\n"
    "has_spfwd(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_has_sprev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_has_sprev" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->has_sprev();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_has_sprev'.\n"
    "  Prototype:\n"
    "has_sprev(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sz_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sz_arg" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sz_arg();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sz_arg'.\n"
    "  Prototype:\n"
    "sz_arg(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sz_res(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sz_res" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sz_res();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sz_res'.\n"
    "  Prototype:\n"
    "sz_res(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sz_iw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sz_iw" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sz_iw();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sz_iw'.\n"
    "  Prototype:\n"
    "sz_iw(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_sz_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_sz_w" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->sz_w();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_sz_w'.\n"
    "  Prototype:\n"
    "sz_w(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 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_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_name" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (std::string *) &((casadi::Function const *)arg1)->name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_name'.\n"
    "  Prototype:\n"
    "name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_is_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_is_a",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_is_a" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->is_a((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_is_a'.\n"
    "  Prototype:\n"
    "is_a(self,str,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_check_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::Function::check_name((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_check_name'.\n"
    "  Prototype:\n"
    "check_name(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_fix_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Function::fix_name((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_fix_name'.\n"
    "  Prototype:\n"
    "fix_name(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_deserialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function result;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "Function_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Function_deserialize" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  {
    try {
      result = casadi::Function::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(std::istream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_deserialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::Function result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Function::deserialize((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Function::load((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_load'.\n"
    "  Prototype:\n"
    "load(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_deserialize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Function_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Function::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_deserialize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_deserialize",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_deserialize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DeserializingStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_deserialize__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_Function_deserialize__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_deserialize'.\n"
    "  Possible prototypes are:\n"
    "    deserialize(std::istream &)\n"
    "    deserialize(casadi::DeserializingStream &)\n"
    "    deserialize(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_assert_size_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_assert_size_in",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_assert_size_in" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      ((casadi::Function const *)arg1)->assert_size_in(arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_assert_size_in'.\n"
    "  Prototype:\n"
    "assert_size_in(self,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_assert_size_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_assert_size_out",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_assert_size_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  {
    try {
      ((casadi::Function const *)arg1)->assert_size_out(arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_assert_size_out'.\n"
    "  Prototype:\n"
    "assert_size_out(self,int,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_assert_sparsity_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 ;
  casadi::Sparsity *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  bool arg5 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m3 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_assert_sparsity_out",3,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_assert_sparsity_out" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Function const *)arg1)->assert_sparsity_out(arg2,(casadi::Sparsity const &)*arg3,arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_assert_sparsity_out'.\n"
    "  Prototype:\n"
    "assert_sparsity_out(self,int,Sparsity,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_checkout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_checkout" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Function const *)arg1)->checkout();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_checkout'.\n"
    "  Prototype:\n"
    "checkout(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_release",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_release" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Function_release" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      ((casadi::Function const *)arg1)->release(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_release'.\n"
    "  Prototype:\n"
    "release(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_cache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_cache" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->cache();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_cache'.\n"
    "  Prototype:\n"
    "cache(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_get_function__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_get_function" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->get_function();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_get_function'.\n"
    "  Prototype:\n"
    "get_function(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_get_function__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_get_function" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Function const *)arg1)->get_function((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Function_get_function'.\n"
    "  Prototype:\n"
    "get_function(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_get_function(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Function_get_function",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Function_get_function__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Function, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_Function_get_function__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Function_get_function'.\n"
    "  Possible prototypes are:\n"
    "    get_function(self)\n"
    "    get_function(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Function_has_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_has_function",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_has_function" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::Function const *)arg1)->has_function((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_has_function'.\n"
    "  Prototype:\n"
    "has_function(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_find_functions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  casadi_int arg2 = (casadi_int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_find_functions",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_find_functions" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->find_functions(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Function" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_find_functions'.\n"
    "  Prototype:\n"
    "find_functions(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_find_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Function_find_function",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_find_function" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Function const *)arg1)->find_function((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_find_function'.\n"
    "  Prototype:\n"
    "find_function(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Function_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = (casadi::Function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Function, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Function_info" "', argument " "1"" of type '" "casadi::Function const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Function * >(argp1);
  {
    try {
      result = ((casadi::Function const *)arg1)->info();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Function_info'.\n"
    "  Prototype:\n"
    "info(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  casadi::Function *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    result = (casadi::Function *)new casadi::Function((casadi::Function const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Function, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Function'.\n"
    "  Prototype:\n"
    "Function(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Function(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Function",0,6,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Function__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_new_Function__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Function **>(0));
    if (_v) {
      return _wrap_new_Function__SWIG_8(self, argc, argv);
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_Function__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_new_Function__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_Function__SWIG_5(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_new_Function__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_Function__SWIG_4(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_new_Function__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_Function__SWIG_7(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_new_Function__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_Function__SWIG_3(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_new_Function__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_Function__SWIG_6(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_new_Function__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Function'.\n"
    "  Possible prototypes are:\n"
    "    Function()\n"
    "    Function(str)\n"
    "    Function(Function)\n"
    "    Function(str,[SX],[SX],dict)\n"
    "    Function(str,[MX],[MX],dict)\n"
    "    Function(str,dict:SX,[str],[str],dict)\n"
    "    Function(str,dict:MX,[str],[str],dict)\n"
    "    Function(str,[SX],[SX],[str],[str],dict)\n"
    "    Function(str,[MX],[MX],[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


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

SWIGINTERN PyObject *_wrap_new_FunctionBuffer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  casadi::Function m1 ;
  casadi::FunctionBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  {
    try {
      result = (casadi::FunctionBuffer *)new casadi::FunctionBuffer((casadi::Function const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__FunctionBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_FunctionBuffer'.\n"
    "  Prototype:\n"
    "FunctionBuffer(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionBuffer_set_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 0 ;
  casadi_int arg2 ;
  double *arg3 = (double *) 0 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Py_buffer *buffer3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"FunctionBuffer_set_arg",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__FunctionBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionBuffer_set_arg" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!PyMemoryView_Check(swig_obj[2])) SWIG_exception_fail(SWIG_TypeError, "Must supply a MemoryView.");
  buffer3 = PyMemoryView_GET_BUFFER(swig_obj[2]);
  arg3 = static_cast<double*>(buffer3->buf); // const double cast comes later
  arg4 = buffer3->len;
  {
    try {
      (arg1)->set_arg(arg2,(double const *)arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'FunctionBuffer_set_arg'.\n"
    "  Prototype:\n"
    "set_arg(self,int,memoryview(ro),casadi_int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionBuffer_set_res(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 0 ;
  casadi_int arg2 ;
  double *arg3 = (double *) 0 ;
  casadi_int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Py_buffer *buffer3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"FunctionBuffer_set_res",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__FunctionBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionBuffer_set_res" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!PyMemoryView_Check(swig_obj[2])) SWIG_exception_fail(SWIG_TypeError, "Must supply a writable MemoryView.");
  buffer3 = PyMemoryView_GET_BUFFER(swig_obj[2]);
  if (buffer3->readonly) SWIG_exception_fail(SWIG_TypeError, "Must supply a writable MemoryView.");
  arg3 = static_cast<double*>(buffer3->buf);
  arg4 = buffer3->len;
  {
    try {
      (arg1)->set_res(arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'FunctionBuffer_set_res'.\n"
    "  Prototype:\n"
    "set_res(self,int,memoryview(rw),casadi_int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionBuffer_ret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 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_casadi__FunctionBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionBuffer_ret" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  {
    try {
      result = (int)(arg1)->ret();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'FunctionBuffer_ret'.\n"
    "  Prototype:\n"
    "ret(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionBuffer__eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 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_casadi__FunctionBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionBuffer__eval" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  {
    try {
      (arg1)->_eval();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'FunctionBuffer__eval'.\n"
    "  Prototype:\n"
    "_eval(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionBuffer__self(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 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_casadi__FunctionBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionBuffer__self" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  {
    try {
      result = (void *)(arg1)->_self();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = PyCapsule_New(result, NULL,NULL);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'FunctionBuffer__self'.\n"
    "  Prototype:\n"
    "_self(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionBuffer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::FunctionBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__FunctionBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionBuffer" "', argument " "1"" of type '" "casadi::FunctionBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FunctionBuffer" "', argument " "1"" of type '" "casadi::FunctionBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  {
    result = (casadi::FunctionBuffer *)new casadi::FunctionBuffer((casadi::FunctionBuffer const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__FunctionBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_FunctionBuffer'.\n"
    "  Prototype:\n"
    "FunctionBuffer(FunctionBuffer)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FunctionBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__FunctionBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FunctionBuffer__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Function **>(0));
    if (_v) {
      return _wrap_new_FunctionBuffer__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_FunctionBuffer'.\n"
    "  Possible prototypes are:\n"
    "    FunctionBuffer(FunctionBuffer)\n"
    "    FunctionBuffer(Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FunctionBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FunctionBuffer *arg1 = (casadi::FunctionBuffer *) 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_casadi__FunctionBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FunctionBuffer" "', argument " "1"" of type '" "casadi::FunctionBuffer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FunctionBuffer * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_FunctionBuffer'.\n"
    "  Prototype:\n"
    "FunctionBuffer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap__function_buffer_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = PyCapsule_GetPointer(swig_obj[0], NULL);
  {
    try {
      casadi::_function_buffer_eval(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function '_function_buffer_eval'.\n"
    "  Prototype:\n"
    "_function_buffer_eval(void*)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_external__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  std::string m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  casadi::Function result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::external((std::string const &)*arg1,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'external'.\n"
    "  Prototype:\n"
    "external(str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_external__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::external((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'external'.\n"
    "  Prototype:\n"
    "external(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_external__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Importer *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__Importer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "external" "', argument " "2"" of type '" "casadi::Importer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "external" "', argument " "2"" of type '" "casadi::Importer const &""'"); 
  }
  arg2 = reinterpret_cast< casadi::Importer * >(argp2);
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::external((std::string const &)*arg1,(casadi::Importer const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'external'.\n"
    "  Prototype:\n"
    "external(str,Importer,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_external(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"external",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_external__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_external__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_casadi__Importer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_external__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_external__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_external__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_external__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'external'.\n"
    "  Possible prototypes are:\n"
    "    external(str,dict)\n"
    "    external(str,Importer,dict)\n"
    "    external(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  double arg4 ;
  std::vector< double,std::allocator< double > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::vector< double > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "float" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:SX,float,[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  double arg4 ;
  std::vector< double,std::allocator< double > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::vector< double > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "float" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:MX,float,[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  double arg4 ;
  std::vector< double,std::allocator< double > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::vector< double > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "float" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,Function,float,[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "float" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:SX,float,float,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "float" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,dict:MX,float,float,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "float" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::integrator((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator'.\n"
    "  Prototype:\n"
    "integrator(str,str,Function,float,float,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"integrator",0,6,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_integrator__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_integrator__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_integrator__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_integrator__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_integrator__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_integrator__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<double> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_3(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< double **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_6(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<double> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_4(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< double **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_7(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<double> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_5(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< double **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_integrator__SWIG_8(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_integrator__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'integrator'.\n"
    "  Possible prototypes are:\n"
    "    integrator(str,str,dict:SX,dict)\n"
    "    integrator(str,str,dict:MX,dict)\n"
    "    integrator(str,str,Function,dict)\n"
    "    integrator(str,str,dict:SX,float,[float],dict)\n"
    "    integrator(str,str,dict:SX,float,float,dict)\n"
    "    integrator(str,str,dict:MX,float,[float],dict)\n"
    "    integrator(str,str,dict:MX,float,float,dict)\n"
    "    integrator(str,str,Function,float,[float],dict)\n"
    "    integrator(str,str,Function,float,float,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_has_integrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_integrator((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_integrator'.\n"
    "  Prototype:\n"
    "has_integrator(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_integrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_integrator((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_integrator'.\n"
    "  Prototype:\n"
    "load_integrator(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_integrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_integrator((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_integrator'.\n"
    "  Prototype:\n"
    "doc_integrator(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::integrator_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'integrator_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::integrator_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'integrator_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::integrator_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator_in'.\n"
    "  Prototype:\n"
    "integrator_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"integrator_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_integrator_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_integrator_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'integrator_in'.\n"
    "  Possible prototypes are:\n"
    "    integrator_in()\n"
    "    integrator_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_integrator_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::integrator_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'integrator_out'.\n"
    "  Prototype:\n"
    "integrator_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"integrator_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_integrator_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_integrator_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'integrator_out'.\n"
    "  Possible prototypes are:\n"
    "    integrator_out()\n"
    "    integrator_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_integrator_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"integrator_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::integrator_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'integrator_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_integrator_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"integrator_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::integrator_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'integrator_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::dyn_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dyn_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::dyn_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dyn_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::dyn_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dyn_in'.\n"
    "  Prototype:\n"
    "dyn_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dyn_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_dyn_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_dyn_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dyn_in'.\n"
    "  Possible prototypes are:\n"
    "    dyn_in()\n"
    "    dyn_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dyn_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::dyn_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dyn_out'.\n"
    "  Prototype:\n"
    "dyn_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dyn_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_dyn_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_dyn_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dyn_out'.\n"
    "  Possible prototypes are:\n"
    "    dyn_out()\n"
    "    dyn_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dyn_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"dyn_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::dyn_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dyn_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dyn_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"dyn_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::dyn_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dyn_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SpDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Sparsity > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"conic",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "Sparsity" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::conic((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Sparsity,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Sparsity > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'conic'.\n"
    "  Prototype:\n"
    "conic(str,str,dict:Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qpsol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::qpsol((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qpsol'.\n"
    "  Prototype:\n"
    "qpsol(str,str,dict:SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qpsol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::qpsol((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qpsol'.\n"
    "  Prototype:\n"
    "qpsol(str,str,dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qpsol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"qpsol",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_qpsol__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_qpsol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_qpsol__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_qpsol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'qpsol'.\n"
    "  Possible prototypes are:\n"
    "    qpsol(str,str,dict:SX,dict)\n"
    "    qpsol(str,str,dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_conic_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::conic_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'conic_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::conic_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'conic_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::conic_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conic_in'.\n"
    "  Prototype:\n"
    "conic_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"conic_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_conic_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_conic_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'conic_in'.\n"
    "  Possible prototypes are:\n"
    "    conic_in()\n"
    "    conic_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_conic_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::conic_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conic_out'.\n"
    "  Prototype:\n"
    "conic_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"conic_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_conic_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_conic_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'conic_out'.\n"
    "  Possible prototypes are:\n"
    "    conic_out()\n"
    "    conic_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_conic_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"conic_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::conic_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'conic_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"conic_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::conic_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'conic_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::conic_options((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'conic_options'.\n"
    "  Prototype:\n"
    "conic_options(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_option_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"conic_option_type",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::conic_option_type((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'conic_option_type'.\n"
    "  Prototype:\n"
    "conic_option_type(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_option_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"conic_option_info",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::conic_option_info((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'conic_option_info'.\n"
    "  Prototype:\n"
    "conic_option_info(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_conic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_conic((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_conic'.\n"
    "  Prototype:\n"
    "has_conic(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_conic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_conic((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_conic'.\n"
    "  Prototype:\n"
    "load_conic(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_conic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_conic((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_conic'.\n"
    "  Prototype:\n"
    "doc_conic(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function m1 ;
  std::string m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      casadi::conic_debug((casadi::Function const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conic_debug'.\n"
    "  Prototype:\n"
    "conic_debug(Function,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Function *arg1 = 0 ;
  std::ostream *arg2 = 0 ;
  casadi::Function m1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "conic_debug" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "conic_debug" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      casadi::conic_debug((casadi::Function const &)*arg1,*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conic_debug'.\n"
    "  Prototype:\n"
    "conic_debug(Function,std::ostream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conic_debug(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"conic_debug",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Function **>(0));
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_conic_debug__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Function **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_conic_debug__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'conic_debug'.\n"
    "  Possible prototypes are:\n"
    "    conic_debug(Function,std::ostream &)\n"
    "    conic_debug(Function,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,dict:SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Importer *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_casadi__Importer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nlpsol" "', argument " "3"" of type '" "casadi::Importer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "nlpsol" "', argument " "3"" of type '" "casadi::Importer const &""'"); 
  }
  arg3 = reinterpret_cast< casadi::Importer * >(argp3);
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Importer const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,Importer,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::NlpBuilder *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_casadi__NlpBuilder,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nlpsol" "', argument " "3"" of type '" "casadi::NlpBuilder const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "nlpsol" "', argument " "3"" of type '" "casadi::NlpBuilder const &""'"); 
  }
  arg3 = reinterpret_cast< casadi::NlpBuilder * >(argp3);
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(casadi::NlpBuilder const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,NlpBuilder,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::nlpsol((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol'.\n"
    "  Prototype:\n"
    "nlpsol(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"nlpsol",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_casadi__Importer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_3(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_casadi__NlpBuilder, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_4(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_nlpsol__SWIG_5(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_nlpsol__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'nlpsol'.\n"
    "  Possible prototypes are:\n"
    "    nlpsol(str,str,Importer,dict)\n"
    "    nlpsol(str,str,NlpBuilder,dict)\n"
    "    nlpsol(str,str,dict:SX,dict)\n"
    "    nlpsol(str,str,dict:MX,dict)\n"
    "    nlpsol(str,str,str,dict)\n"
    "    nlpsol(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nlpsol_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::nlpsol_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'nlpsol_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::nlpsol_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'nlpsol_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::nlpsol_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_in'.\n"
    "  Prototype:\n"
    "nlpsol_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"nlpsol_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_nlpsol_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_nlpsol_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'nlpsol_in'.\n"
    "  Possible prototypes are:\n"
    "    nlpsol_in()\n"
    "    nlpsol_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nlpsol_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::nlpsol_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_out'.\n"
    "  Prototype:\n"
    "nlpsol_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"nlpsol_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_nlpsol_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_nlpsol_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'nlpsol_out'.\n"
    "  Possible prototypes are:\n"
    "    nlpsol_out()\n"
    "    nlpsol_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nlpsol_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"nlpsol_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::nlpsol_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'nlpsol_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"nlpsol_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::nlpsol_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'nlpsol_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_default_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = (double)casadi::nlpsol_default_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_default_in'.\n"
    "  Prototype:\n"
    "nlpsol_default_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_default_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::nlpsol_default_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'nlpsol_default_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_default_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"nlpsol_default_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_nlpsol_default_in__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_nlpsol_default_in__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'nlpsol_default_in'.\n"
    "  Possible prototypes are:\n"
    "    nlpsol_default_in()\n"
    "    nlpsol_default_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nlpsol_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::nlpsol_options((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_options'.\n"
    "  Prototype:\n"
    "nlpsol_options(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_option_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"nlpsol_option_type",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::nlpsol_option_type((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_option_type'.\n"
    "  Prototype:\n"
    "nlpsol_option_type(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nlpsol_option_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"nlpsol_option_info",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::nlpsol_option_info((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'nlpsol_option_info'.\n"
    "  Prototype:\n"
    "nlpsol_option_info(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_nlpsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_nlpsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_nlpsol'.\n"
    "  Prototype:\n"
    "has_nlpsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_nlpsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_nlpsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_nlpsol'.\n"
    "  Prototype:\n"
    "load_nlpsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_nlpsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_nlpsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_nlpsol'.\n"
    "  Prototype:\n"
    "doc_nlpsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::rootfinder((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder'.\n"
    "  Prototype:\n"
    "rootfinder(str,str,dict:SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::MXDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::rootfinder((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder'.\n"
    "  Prototype:\n"
    "rootfinder(str,str,dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::rootfinder((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder'.\n"
    "  Prototype:\n"
    "rootfinder(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rootfinder",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_rootfinder__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_rootfinder__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_rootfinder__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_rootfinder__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Function **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_rootfinder__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_rootfinder__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'rootfinder'.\n"
    "  Possible prototypes are:\n"
    "    rootfinder(str,str,dict:SX,dict)\n"
    "    rootfinder(str,str,dict:MX,dict)\n"
    "    rootfinder(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_rootfinder_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::rootfinder_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'rootfinder_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::rootfinder_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'rootfinder_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::rootfinder_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder_in'.\n"
    "  Prototype:\n"
    "rootfinder_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rootfinder_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_rootfinder_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_rootfinder_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'rootfinder_in'.\n"
    "  Possible prototypes are:\n"
    "    rootfinder_in()\n"
    "    rootfinder_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_rootfinder_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::rootfinder_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder_out'.\n"
    "  Prototype:\n"
    "rootfinder_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rootfinder_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_rootfinder_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_rootfinder_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'rootfinder_out'.\n"
    "  Possible prototypes are:\n"
    "    rootfinder_out()\n"
    "    rootfinder_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_rootfinder_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"rootfinder_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::rootfinder_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'rootfinder_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"rootfinder_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::rootfinder_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'rootfinder_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::rootfinder_options((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder_options'.\n"
    "  Prototype:\n"
    "rootfinder_options(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_option_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"rootfinder_option_type",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::rootfinder_option_type((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder_option_type'.\n"
    "  Prototype:\n"
    "rootfinder_option_type(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rootfinder_option_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string m1 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"rootfinder_option_info",2,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = casadi::rootfinder_option_info((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'rootfinder_option_info'.\n"
    "  Prototype:\n"
    "rootfinder_option_info(str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_rootfinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_rootfinder((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_rootfinder'.\n"
    "  Prototype:\n"
    "has_rootfinder(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_rootfinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_rootfinder((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_rootfinder'.\n"
    "  Prototype:\n"
    "load_rootfinder(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_rootfinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_rootfinder((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_rootfinder'.\n"
    "  Prototype:\n"
    "doc_rootfinder(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Linsol::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'Linsol_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Linsol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Linsol *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Linsol *)new casadi::Linsol();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Linsol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_Linsol'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Linsol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Sparsity m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Linsol *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Linsol *)new casadi::Linsol((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Sparsity const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Linsol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Linsol'.\n"
    "  Prototype:\n"
    "Linsol(str,str,Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_has_plugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::Linsol::has_plugin((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_has_plugin'.\n"
    "  Prototype:\n"
    "has_plugin(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_load_plugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::Linsol::load_plugin((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_load_plugin'.\n"
    "  Prototype:\n"
    "load_plugin(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_doc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Linsol::doc((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_doc'.\n"
    "  Prototype:\n"
    "doc(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_plugin_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 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_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_plugin_name" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  {
    try {
      result = ((casadi::Linsol const *)arg1)->plugin_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_plugin_name'.\n"
    "  Prototype:\n"
    "plugin_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_sparsity" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  {
    try {
      result = (casadi::Sparsity *) &((casadi::Linsol const *)arg1)->sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_sparsity'.\n"
    "  Prototype:\n"
    "sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_sfact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::DM *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_sfact",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_sfact" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      ((casadi::Linsol const *)arg1)->sfact((casadi::DM const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_sfact'.\n"
    "  Prototype:\n"
    "sfact(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_nfact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::DM *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_nfact",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_nfact" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      ((casadi::Linsol const *)arg1)->nfact((casadi::DM const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_nfact'.\n"
    "  Prototype:\n"
    "nfact(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_solve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::DM *arg2 = 0 ;
  casadi::DM *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::DM result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_solve" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Linsol const *)arg1)->solve((casadi::DM const &)*arg2,(casadi::DM const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_solve'.\n"
    "  Prototype:\n"
    "solve(self,DM,DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_solve" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Linsol const *)arg1)->solve((casadi::MX const &)*arg2,(casadi::MX const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_solve'.\n"
    "  Prototype:\n"
    "solve(self,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Linsol_solve",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Linsol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Linsol_solve__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Linsol_solve__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Linsol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_Linsol_solve__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_Linsol_solve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Linsol_solve'.\n"
    "  Possible prototypes are:\n"
    "    solve(self,DM,DM,bool)\n"
    "    solve(self,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Linsol_neig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::DM *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_neig",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_neig" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (casadi_int)((casadi::Linsol const *)arg1)->neig((casadi::DM const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_neig'.\n"
    "  Prototype:\n"
    "neig(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  casadi::DM *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_rank",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_rank" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (casadi_int)((casadi::Linsol const *)arg1)->rank((casadi::DM const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_rank'.\n"
    "  Prototype:\n"
    "rank(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Linsol_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::Dict result;
  
  if (!SWIG_Python_UnpackTuple(args,"Linsol_stats",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Linsol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linsol_stats" "', argument " "1"" of type '" "casadi::Linsol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Linsol_stats" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  {
    try {
      result = ((casadi::Linsol const *)arg1)->stats(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Linsol_stats'.\n"
    "  Prototype:\n"
    "stats(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Linsol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Linsol *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__Linsol,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Linsol" "', argument " "1"" of type '" "casadi::Linsol const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Linsol" "', argument " "1"" of type '" "casadi::Linsol const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  {
    result = (casadi::Linsol *)new casadi::Linsol((casadi::Linsol const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Linsol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Linsol'.\n"
    "  Prototype:\n"
    "Linsol(Linsol)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Linsol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Linsol",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Linsol__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__Linsol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Linsol__SWIG_2(self, argc, argv);
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_Linsol__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_new_Linsol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Linsol'.\n"
    "  Possible prototypes are:\n"
    "    Linsol()\n"
    "    Linsol(Linsol)\n"
    "    Linsol(str,str,Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Linsol *arg1 = (casadi::Linsol *) 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_casadi__Linsol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Linsol" "', argument " "1"" of type '" "casadi::Linsol *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Linsol * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Linsol'.\n"
    "  Prototype:\n"
    "Linsol(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_has_linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_linsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_linsol'.\n"
    "  Prototype:\n"
    "has_linsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_linsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_linsol'.\n"
    "  Prototype:\n"
    "load_linsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_linsol((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_linsol'.\n"
    "  Prototype:\n"
    "doc_linsol(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dplesol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::SpDict *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::Sparsity > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "Sparsity" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dplesol((std::string const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::Sparsity,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Sparsity > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dplesol'.\n"
    "  Prototype:\n"
    "dplesol(str,str,dict:Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dplesol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dplesol((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dplesol'.\n"
    "  Prototype:\n"
    "dplesol(MX,MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dplesol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MXVector *arg1 = 0 ;
  casadi::MXVector *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::MXVector result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dplesol((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dplesol'.\n"
    "  Prototype:\n"
    "dplesol([MX],[MX],str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dplesol__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DMVector *arg1 = 0 ;
  casadi::DMVector *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::DMVector result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dplesol((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dplesol'.\n"
    "  Prototype:\n"
    "dplesol([DM],[DM],str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dplesol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dplesol",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dplesol__SWIG_3(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_dplesol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dplesol__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_dplesol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dplesol__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_dplesol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::Sparsity > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dplesol__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_dplesol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dplesol'.\n"
    "  Possible prototypes are:\n"
    "    dplesol([DM],[DM],str,dict)\n"
    "    dplesol(MX,MX,str,dict)\n"
    "    dplesol([MX],[MX],str,dict)\n"
    "    dplesol(str,str,dict:Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dple_in__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::dple_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dple_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dple_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = casadi::dple_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dple_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dple_in__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::dple_in(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dple_in'.\n"
    "  Prototype:\n"
    "dple_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dple_in(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dple_in",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_dple_in__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_dple_in__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dple_in'.\n"
    "  Possible prototypes are:\n"
    "    dple_in()\n"
    "    dple_in(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dple_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      result = casadi::dple_out(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dple_out'.\n"
    "  Prototype:\n"
    "dple_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dple_out(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dple_out",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_dple_out__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi_int **>(0));
    if (_v) {
      return _wrap_dple_out__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dple_out'.\n"
    "  Possible prototypes are:\n"
    "    dple_out()\n"
    "    dple_out(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dple_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"dple_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::dple_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dple_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dple_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"dple_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::dple_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'dple_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_dple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_dple((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_dple'.\n"
    "  Prototype:\n"
    "has_dple(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_dple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_dple((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_dple'.\n"
    "  Prototype:\n"
    "load_dple(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_dple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_dple((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_dple'.\n"
    "  Prototype:\n"
    "doc_dple(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expmsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Sparsity m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"expmsol",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::expmsol((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Sparsity const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'expmsol'.\n"
    "  Prototype:\n"
    "expmsol(str,str,Sparsity,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"expm_n_in",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::expm_n_in();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'expm_n_in'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"expm_n_out",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::expm_n_out();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'expm_n_out'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_expm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_expm((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_expm'.\n"
    "  Prototype:\n"
    "has_expm(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_expm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_expm((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_expm'.\n"
    "  Prototype:\n"
    "load_expm(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_expm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_expm((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_expm'.\n"
    "  Prototype:\n"
    "doc_expm(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolant__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< std::vector< double > > m3 ;
  std::vector< double > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "float" "]" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "float" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::interpolant((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interpolant'.\n"
    "  Prototype:\n"
    "interpolant(str,str,[[float]],[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolant__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< std::vector< double > > m3 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "float" "]" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::interpolant((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interpolant'.\n"
    "  Prototype:\n"
    "interpolant(str,str,[[float]],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolant__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< casadi_int > m3 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::interpolant((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interpolant'.\n"
    "  Prototype:\n"
    "interpolant(str,str,[int],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolant__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< double > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "float" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::interpolant((std::string const &)*arg1,(std::string const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interpolant'.\n"
    "  Prototype:\n"
    "interpolant(str,str,[int],[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interpolant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"interpolant",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<double> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_interpolant__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interpolant__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_interpolant__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_interpolant__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interpolant__SWIG_2(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_interpolant__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<double> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<double> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interpolant__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_interpolant__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<double> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interpolant__SWIG_3(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_interpolant__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'interpolant'.\n"
    "  Possible prototypes are:\n"
    "    interpolant(str,str,[[float]],int,dict)\n"
    "    interpolant(str,str,[int],int,dict)\n"
    "    interpolant(str,str,[[float]],[float],dict)\n"
    "    interpolant(str,str,[int],[float],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_has_interpolant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::has_interpolant((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'has_interpolant'.\n"
    "  Prototype:\n"
    "has_interpolant(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_load_interpolant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::load_interpolant((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'load_interpolant'.\n"
    "  Prototype:\n"
    "load_interpolant(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_doc_interpolant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::doc_interpolant((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'doc_interpolant'.\n"
    "  Prototype:\n"
    "doc_interpolant(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CodeGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  std::string m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  casadi::CodeGenerator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CodeGenerator",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::CodeGenerator *)new casadi::CodeGenerator((std::string const &)*arg1,(casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__CodeGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_CodeGenerator'.\n"
    "  Prototype:\n"
    "CodeGenerator(str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CodeGenerator_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CodeGenerator *arg1 = (casadi::CodeGenerator *) 0 ;
  casadi::Function *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function m2 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"CodeGenerator_add",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__CodeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CodeGenerator_add" "', argument " "1"" of type '" "casadi::CodeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CodeGenerator * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Function" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->add((casadi::Function const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'CodeGenerator_add'.\n"
    "  Prototype:\n"
    "add(self,Function,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CodeGenerator_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CodeGenerator *arg1 = (casadi::CodeGenerator *) 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_casadi__CodeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CodeGenerator_dump" "', argument " "1"" of type '" "casadi::CodeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CodeGenerator * >(argp1);
  {
    try {
      result = (arg1)->dump();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'CodeGenerator_dump'.\n"
    "  Prototype:\n"
    "dump(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CodeGenerator_generate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CodeGenerator *arg1 = (casadi::CodeGenerator *) 0 ;
  std::string const &arg2_defvalue = "" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"CodeGenerator_generate",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__CodeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CodeGenerator_generate" "', argument " "1"" of type '" "casadi::CodeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CodeGenerator * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->generate((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'CodeGenerator_generate'.\n"
    "  Prototype:\n"
    "generate(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CodeGenerator_add_include(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CodeGenerator *arg1 = (casadi::CodeGenerator *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 = (bool) false ;
  std::string const &arg4_defvalue = std::string() ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m4 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"CodeGenerator_add_include",2,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__CodeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CodeGenerator_add_include" "', argument " "1"" of type '" "casadi::CodeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CodeGenerator * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  {
    try {
      (arg1)->add_include((std::string const &)*arg2,arg3,(std::string const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'CodeGenerator_add_include'.\n"
    "  Prototype:\n"
    "add_include(self,str,bool,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CodeGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CodeGenerator *arg1 = (casadi::CodeGenerator *) 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_casadi__CodeGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CodeGenerator" "', argument " "1"" of type '" "casadi::CodeGenerator *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CodeGenerator * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_CodeGenerator'.\n"
    "  Prototype:\n"
    "CodeGenerator(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap__horzcat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  std::vector< casadi::Sparsity > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      result = casadi::casadi_horzcat((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_horzcat'.\n"
    "  Prototype:\n"
    "_horzcat([Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__vertcat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  std::vector< casadi::Sparsity > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      result = casadi::casadi_vertcat((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_vertcat'.\n"
    "  Prototype:\n"
    "_vertcat([Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Sparsity const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(Sparsity,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit_n__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_horzsplit_n((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit_n'.\n"
    "  Prototype:\n"
    "horzsplit_n(Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Sparsity const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(Sparsity,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_offset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  std::vector< casadi::Sparsity > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_offset((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'offset'.\n"
    "  Prototype:\n"
    "offset([Sparsity],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit_n__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_vertsplit_n((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit_n'.\n"
    "  Prototype:\n"
    "vertsplit_n(Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  casadi::Sparsity *arg4 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity m3 ;
  casadi::Sparsity m4 ;
  casadi::Sparsity result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_blockcat((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2,(casadi::Sparsity const &)*arg3,(casadi::Sparsity const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat(Sparsity,Sparsity,Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Sparsity m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > >,std::allocator< std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Sparsity const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "Sparsity"  "]"  "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(Sparsity,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Sparsity m1 ;
  std::vector< std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > >,std::allocator< std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > > > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Sparsity const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "Sparsity"  "]"  "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__diagcat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  std::vector< casadi::Sparsity > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      result = casadi::casadi_diagcat((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_diagcat'.\n"
    "  Prototype:\n"
    "_diagcat([Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Sparsity m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Sparsity const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(Sparsity,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Sparsity const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(Sparsity,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(Sparsity,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Sparsity m1 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Sparsity const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__veccat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  std::vector< casadi::Sparsity > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      result = casadi::casadi_veccat((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_veccat'.\n"
    "  Prototype:\n"
    "_veccat([Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_mtimes((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes(Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg1 = 0 ;
  std::vector< casadi::Sparsity > m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      result = casadi::casadi_mtimes((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes([Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity m3 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_mac((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2,(casadi::Sparsity const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mac'.\n"
    "  Prototype:\n"
    "mac(Sparsity,Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_transpose((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'transpose'.\n"
    "  Prototype:\n"
    "transpose(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_vec((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vec'.\n"
    "  Prototype:\n"
    "vec(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Sparsity const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > arg2 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(Sparsity,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsity_cast__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sparsity_cast((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsity_cast'.\n"
    "  Prototype:\n"
    "sparsity_cast(Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sprank__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_sprank((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sprank'.\n"
    "  Prototype:\n"
    "sprank(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_0_mul__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_norm_0_mul((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_0_mul'.\n"
    "  Prototype:\n"
    "norm_0_mul(Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_triu((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu'.\n"
    "  Prototype:\n"
    "triu(Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_tril((casadi::Sparsity const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril'.\n"
    "  Prototype:\n"
    "tril(Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_kron((casadi::Sparsity const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'kron'.\n"
    "  Prototype:\n"
    "kron(Sparsity,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repmat((casadi::Sparsity const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(Sparsity,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  casadi::Sparsity m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_repmat((casadi::Sparsity const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(Sparsity,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sum2((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum2'.\n"
    "  Prototype:\n"
    "sum2(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Sparsity *arg1 = 0 ;
  casadi::Sparsity m1 ;
  casadi::Sparsity result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sum1((casadi::Sparsity const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum1'.\n"
    "  Prototype:\n"
    "sum1(Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__horzcat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_horzcat((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_horzcat'.\n"
    "  Prototype:\n"
    "_horzcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__vertcat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_vertcat((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_vertcat'.\n"
    "  Prototype:\n"
    "_vertcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_horzsplit((casadi::MX const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(MX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_horzsplit((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit_n__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_horzsplit_n((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit_n'.\n"
    "  Prototype:\n"
    "horzsplit_n(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_vertsplit((casadi::MX const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(MX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_offset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_offset((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'offset'.\n"
    "  Prototype:\n"
    "offset([MX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_vertsplit((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit_n__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_vertsplit_n((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit_n'.\n"
    "  Prototype:\n"
    "vertsplit_n(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  casadi::MX result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_blockcat((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat(MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_blocksplit((casadi::MX const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(MX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::MX m1 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_blocksplit((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__diagcat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_diagcat((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_diagcat'.\n"
    "  Prototype:\n"
    "_diagcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::MX const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(MX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::MX const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(MX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diagsplit((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__veccat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_veccat((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_veccat'.\n"
    "  Prototype:\n"
    "_veccat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mtimes((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_mtimes((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mac((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mac'.\n"
    "  Prototype:\n"
    "mac(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_transpose((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'transpose'.\n"
    "  Prototype:\n"
    "transpose(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_vec((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vec'.\n"
    "  Prototype:\n"
    "vec(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > arg2 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(MX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::Sparsity m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::MX const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(MX,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsity_cast__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::Sparsity m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sparsity_cast((casadi::MX const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsity_cast'.\n"
    "  Prototype:\n"
    "sparsity_cast(MX,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sprank__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_sprank((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sprank'.\n"
    "  Prototype:\n"
    "sprank(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_0_mul__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_norm_0_mul((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_0_mul'.\n"
    "  Prototype:\n"
    "norm_0_mul(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_triu((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu'.\n"
    "  Prototype:\n"
    "triu(MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_tril((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril'.\n"
    "  Prototype:\n"
    "tril(MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_kron((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'kron'.\n"
    "  Prototype:\n"
    "kron(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repmat((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  casadi::MX m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_repmat((casadi::MX const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(MX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sum2((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum2'.\n"
    "  Prototype:\n"
    "sum2(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sum1((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum1'.\n"
    "  Prototype:\n"
    "sum1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__horzcat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_horzcat((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_horzcat'.\n"
    "  Prototype:\n"
    "_horzcat([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__vertcat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_vertcat((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_vertcat'.\n"
    "  Prototype:\n"
    "_vertcat([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Matrix< double > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(DM,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit_n__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_horzsplit_n((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit_n'.\n"
    "  Prototype:\n"
    "horzsplit_n(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Matrix< double > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(DM,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_offset__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_offset((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'offset'.\n"
    "  Prototype:\n"
    "offset([DM],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit_n__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_vertsplit_n((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit_n'.\n"
    "  Prototype:\n"
    "vertsplit_n(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_blockcat((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(casadi::Matrix< double > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat(DM,DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Matrix< double > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(DM,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__diagcat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_diagcat((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_diagcat'.\n"
    "  Prototype:\n"
    "_diagcat([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< double > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(DM,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< double > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(DM,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__veccat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_veccat((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_veccat'.\n"
    "  Prototype:\n"
    "_veccat([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mtimes((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_mtimes((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mac__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mac((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mac'.\n"
    "  Prototype:\n"
    "mac(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_transpose((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'transpose'.\n"
    "  Prototype:\n"
    "transpose(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_vec((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vec'.\n"
    "  Prototype:\n"
    "vec(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > arg2 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(DM,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< double > const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(DM,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsity_cast__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sparsity_cast((casadi::Matrix< double > const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsity_cast'.\n"
    "  Prototype:\n"
    "sparsity_cast(DM,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sprank__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_sprank((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sprank'.\n"
    "  Prototype:\n"
    "sprank(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_0_mul__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_norm_0_mul((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_0_mul'.\n"
    "  Prototype:\n"
    "norm_0_mul(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_triu((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu'.\n"
    "  Prototype:\n"
    "triu(DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_tril((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril'.\n"
    "  Prototype:\n"
    "tril(DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_kron((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'kron'.\n"
    "  Prototype:\n"
    "kron(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repmat((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_repmat((casadi::Matrix< double > const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(DM,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sum2((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum2'.\n"
    "  Prototype:\n"
    "sum2(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sum1((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum1'.\n"
    "  Prototype:\n"
    "sum1(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__horzcat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_horzcat((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_horzcat'.\n"
    "  Prototype:\n"
    "_horzcat([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__horzcat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"_horzcat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      return _wrap__horzcat__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap__horzcat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap__horzcat__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap__horzcat__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function '_horzcat'.\n"
    "  Possible prototypes are:\n"
    "    _horzcat([Sparsity])\n"
    "    _horzcat([DM])\n"
    "    _horzcat([SX])\n"
    "    _horzcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap__vertcat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_vertcat((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_vertcat'.\n"
    "  Prototype:\n"
    "_vertcat([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__vertcat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"_vertcat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      return _wrap__vertcat__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap__vertcat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap__vertcat__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap__vertcat__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function '_vertcat'.\n"
    "  Possible prototypes are:\n"
    "    _vertcat([Sparsity])\n"
    "    _vertcat([DM])\n"
    "    _vertcat([SX])\n"
    "    _vertcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(SX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_horzsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit'.\n"
    "  Prototype:\n"
    "horzsplit(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"horzsplit",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_horzsplit__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_horzsplit__SWIG_5(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_5(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_horzsplit__SWIG_7(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_7(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_horzsplit__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_horzsplit__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'horzsplit'.\n"
    "  Possible prototypes are:\n"
    "    horzsplit(Sparsity,int)\n"
    "    horzsplit(DM,int)\n"
    "    horzsplit(SX,int)\n"
    "    horzsplit(MX,int)\n"
    "    horzsplit(Sparsity,[int])\n"
    "    horzsplit(DM,[int])\n"
    "    horzsplit(SX,[int])\n"
    "    horzsplit(MX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_horzsplit_n__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_horzsplit_n((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'horzsplit_n'.\n"
    "  Prototype:\n"
    "horzsplit_n(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_horzsplit_n(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"horzsplit_n",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit_n__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit_n__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit_n__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_horzsplit_n__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'horzsplit_n'.\n"
    "  Possible prototypes are:\n"
    "    horzsplit_n(Sparsity,int)\n"
    "    horzsplit_n(DM,int)\n"
    "    horzsplit_n(SX,int)\n"
    "    horzsplit_n(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(SX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_offset__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_offset((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'offset'.\n"
    "  Prototype:\n"
    "offset([SX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_offset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"offset",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_offset__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_offset__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_offset__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_offset__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_offset__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_offset__SWIG_3(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_offset__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_offset__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'offset'.\n"
    "  Possible prototypes are:\n"
    "    offset([Sparsity],bool)\n"
    "    offset([DM],bool)\n"
    "    offset([SX],bool)\n"
    "    offset([MX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_vertsplit__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_vertsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit'.\n"
    "  Prototype:\n"
    "vertsplit(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"vertsplit",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_vertsplit__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_vertsplit__SWIG_5(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_5(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_vertsplit__SWIG_7(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_7(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_vertsplit__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_vertsplit__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'vertsplit'.\n"
    "  Possible prototypes are:\n"
    "    vertsplit(Sparsity,int)\n"
    "    vertsplit(DM,int)\n"
    "    vertsplit(SX,int)\n"
    "    vertsplit(MX,int)\n"
    "    vertsplit(Sparsity,[int])\n"
    "    vertsplit(DM,[int])\n"
    "    vertsplit(SX,[int])\n"
    "    vertsplit(MX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_vertsplit_n__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_vertsplit_n((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vertsplit_n'.\n"
    "  Prototype:\n"
    "vertsplit_n(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vertsplit_n(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"vertsplit_n",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit_n__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit_n__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit_n__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_vertsplit_n__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'vertsplit_n'.\n"
    "  Possible prototypes are:\n"
    "    vertsplit_n(Sparsity,int)\n"
    "    vertsplit_n(DM,int)\n"
    "    vertsplit_n(SX,int)\n"
    "    vertsplit_n(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_blockcat((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat(SX,SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(SX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_blocksplit((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blocksplit'.\n"
    "  Prototype:\n"
    "blocksplit(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blocksplit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"blocksplit",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_blocksplit__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_blocksplit__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_blocksplit__SWIG_5(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_blocksplit__SWIG_5(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_blocksplit__SWIG_7(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_blocksplit__SWIG_7(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_blocksplit__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_blocksplit__SWIG_3(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_blocksplit__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'blocksplit'.\n"
    "  Possible prototypes are:\n"
    "    blocksplit(Sparsity,int,int)\n"
    "    blocksplit(DM,int,int)\n"
    "    blocksplit(SX,int,int)\n"
    "    blocksplit(MX,int,int)\n"
    "    blocksplit(Sparsity,[int],[int])\n"
    "    blocksplit(DM,[int],[int])\n"
    "    blocksplit(SX,[int],[int])\n"
    "    blocksplit(MX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap__diagcat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_diagcat((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_diagcat'.\n"
    "  Prototype:\n"
    "_diagcat([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__diagcat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"_diagcat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      return _wrap__diagcat__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap__diagcat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap__diagcat__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap__diagcat__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function '_diagcat'.\n"
    "  Possible prototypes are:\n"
    "    _diagcat([Sparsity])\n"
    "    _diagcat([DM])\n"
    "    _diagcat([SX])\n"
    "    _diagcat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(SX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi_int > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< long long,std::allocator< long long > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(SX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_14(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit__SWIG_15(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_diagsplit((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diagsplit'.\n"
    "  Prototype:\n"
    "diagsplit(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diagsplit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"diagsplit",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diagsplit__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diagsplit__SWIG_10(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_10(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diagsplit__SWIG_14(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_14(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diagsplit__SWIG_6(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_13(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_diagsplit__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_15(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          return _wrap_diagsplit__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'diagsplit'.\n"
    "  Possible prototypes are:\n"
    "    diagsplit(Sparsity,int)\n"
    "    diagsplit(DM,int)\n"
    "    diagsplit(SX,int)\n"
    "    diagsplit(MX,int)\n"
    "    diagsplit(Sparsity,[int])\n"
    "    diagsplit(DM,[int])\n"
    "    diagsplit(SX,[int])\n"
    "    diagsplit(MX,[int])\n"
    "    diagsplit(Sparsity,int,int)\n"
    "    diagsplit(Sparsity,[int],[int])\n"
    "    diagsplit(DM,int,int)\n"
    "    diagsplit(DM,[int],[int])\n"
    "    diagsplit(SX,int,int)\n"
    "    diagsplit(SX,[int],[int])\n"
    "    diagsplit(MX,int,int)\n"
    "    diagsplit(MX,[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap__veccat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_veccat((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function '_veccat'.\n"
    "  Prototype:\n"
    "_veccat([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap__veccat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"_veccat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      return _wrap__veccat__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap__veccat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap__veccat__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap__veccat__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function '_veccat'.\n"
    "  Possible prototypes are:\n"
    "    _veccat([Sparsity])\n"
    "    _veccat([DM])\n"
    "    _veccat([SX])\n"
    "    _veccat([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mtimes((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_mtimes((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtimes'.\n"
    "  Prototype:\n"
    "mtimes([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtimes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mtimes",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Sparsity> **>(0));
    if (_v) {
      return _wrap_mtimes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap_mtimes__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap_mtimes__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap_mtimes__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_mtimes__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_mtimes__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_mtimes__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_mtimes__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mtimes'.\n"
    "  Possible prototypes are:\n"
    "    mtimes([Sparsity])\n"
    "    mtimes([DM])\n"
    "    mtimes([SX])\n"
    "    mtimes([MX])\n"
    "    mtimes(Sparsity,Sparsity)\n"
    "    mtimes(DM,DM)\n"
    "    mtimes(SX,SX)\n"
    "    mtimes(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mac__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mac((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mac'.\n"
    "  Prototype:\n"
    "mac(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mac",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_mac__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_mac__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_mac__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_mac__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mac'.\n"
    "  Possible prototypes are:\n"
    "    mac(Sparsity,Sparsity,Sparsity)\n"
    "    mac(DM,DM,DM)\n"
    "    mac(SX,SX,SX)\n"
    "    mac(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_transpose((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'transpose'.\n"
    "  Prototype:\n"
    "transpose(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"transpose",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_transpose__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_transpose__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_transpose__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_transpose__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'transpose'.\n"
    "  Possible prototypes are:\n"
    "    transpose(Sparsity)\n"
    "    transpose(DM)\n"
    "    transpose(SX)\n"
    "    transpose(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_vec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_vec((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'vec'.\n"
    "  Prototype:\n"
    "vec(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"vec",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_vec__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_vec__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_vec__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_vec__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'vec'.\n"
    "  Possible prototypes are:\n"
    "    vec(Sparsity)\n"
    "    vec(DM)\n"
    "    vec(SX)\n"
    "    vec(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > arg2 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(SX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_reshape((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reshape'.\n"
    "  Prototype:\n"
    "reshape(SX,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reshape(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"reshape",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_10(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_reshape__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_reshape__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_reshape__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_reshape__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_reshape__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'reshape'.\n"
    "  Possible prototypes are:\n"
    "    reshape(Sparsity,(int,int))\n"
    "    reshape(Sparsity,Sparsity)\n"
    "    reshape(DM,(int,int))\n"
    "    reshape(DM,Sparsity)\n"
    "    reshape(SX,(int,int))\n"
    "    reshape(SX,Sparsity)\n"
    "    reshape(MX,(int,int))\n"
    "    reshape(MX,Sparsity)\n"
    "    reshape(Sparsity,int,int)\n"
    "    reshape(DM,int,int)\n"
    "    reshape(SX,int,int)\n"
    "    reshape(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sparsity_cast__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      result = casadi::casadi_sparsity_cast((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsity_cast'.\n"
    "  Prototype:\n"
    "sparsity_cast(SX,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsity_cast(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sparsity_cast",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_sparsity_cast__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_sparsity_cast__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_sparsity_cast__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_sparsity_cast__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sparsity_cast'.\n"
    "  Possible prototypes are:\n"
    "    sparsity_cast(Sparsity,Sparsity)\n"
    "    sparsity_cast(DM,Sparsity)\n"
    "    sparsity_cast(SX,Sparsity)\n"
    "    sparsity_cast(MX,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sprank__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_sprank((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sprank'.\n"
    "  Prototype:\n"
    "sprank(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sprank(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sprank",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_sprank__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sprank__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sprank__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sprank__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sprank'.\n"
    "  Possible prototypes are:\n"
    "    sprank(Sparsity)\n"
    "    sprank(DM)\n"
    "    sprank(SX)\n"
    "    sprank(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_0_mul__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi_int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_norm_0_mul((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_0_mul'.\n"
    "  Prototype:\n"
    "norm_0_mul(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_0_mul(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_0_mul",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_norm_0_mul__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_norm_0_mul__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_norm_0_mul__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_norm_0_mul__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_0_mul'.\n"
    "  Possible prototypes are:\n"
    "    norm_0_mul(Sparsity,Sparsity)\n"
    "    norm_0_mul(DM,DM)\n"
    "    norm_0_mul(SX,SX)\n"
    "    norm_0_mul(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_triu__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_triu((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu'.\n"
    "  Prototype:\n"
    "triu(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"triu",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_triu__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_triu__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_triu__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_triu__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_triu__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_triu__SWIG_3(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_triu__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_triu__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'triu'.\n"
    "  Possible prototypes are:\n"
    "    triu(Sparsity,bool)\n"
    "    triu(DM,bool)\n"
    "    triu(SX,bool)\n"
    "    triu(MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_tril__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  bool arg2 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_tril((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril'.\n"
    "  Prototype:\n"
    "tril(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"tril",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_tril__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_tril__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_tril__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_tril__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_tril__SWIG_3(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_tril__SWIG_3(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_tril__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_tril__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'tril'.\n"
    "  Possible prototypes are:\n"
    "    tril(Sparsity,bool)\n"
    "    tril(DM,bool)\n"
    "    tril(SX,bool)\n"
    "    tril(MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_kron__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_kron((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'kron'.\n"
    "  Prototype:\n"
    "kron(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_kron(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"kron",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_kron__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_kron__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_kron__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_kron__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'kron'.\n"
    "  Possible prototypes are:\n"
    "    kron(Sparsity,Sparsity)\n"
    "    kron(DM,DM)\n"
    "    kron(SX,SX)\n"
    "    kron(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repmat((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::pair< casadi_int,casadi_int > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::pair< casadi_int,casadi_int > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "(" "int" "," "int" ")" "'.");
  {
    try {
      result = casadi::casadi_repmat((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::pair< long long,long long > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repmat'.\n"
    "  Prototype:\n"
    "repmat(SX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"repmat",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repmat__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repmat__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_repmat__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repmat__SWIG_4(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repmat__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_repmat__SWIG_5(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repmat__SWIG_6(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repmat__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_repmat__SWIG_7(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repmat__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repmat__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::pair<casadi_int,casadi_int> **>(0));
      if (_v) {
        return _wrap_repmat__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'repmat'.\n"
    "  Possible prototypes are:\n"
    "    repmat(Sparsity,int,int)\n"
    "    repmat(Sparsity,(int,int))\n"
    "    repmat(DM,int,int)\n"
    "    repmat(DM,(int,int))\n"
    "    repmat(SX,int,int)\n"
    "    repmat(SX,(int,int))\n"
    "    repmat(MX,int,int)\n"
    "    repmat(MX,(int,int))\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sum2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sum2((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum2'.\n"
    "  Prototype:\n"
    "sum2(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sum2",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_sum2__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sum2__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sum2__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sum2__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sum2'.\n"
    "  Possible prototypes are:\n"
    "    sum2(Sparsity)\n"
    "    sum2(DM)\n"
    "    sum2(SX)\n"
    "    sum2(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sum1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sum1((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sum1'.\n"
    "  Prototype:\n"
    "sum1(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sum1",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      return _wrap_sum1__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sum1__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sum1__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sum1__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sum1'.\n"
    "  Possible prototypes are:\n"
    "    sum1(Sparsity)\n"
    "    sum1(DM)\n"
    "    sum1(SX)\n"
    "    sum1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_plus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_plus((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'plus'.\n"
    "  Prototype:\n"
    "plus(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_minus((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minus'.\n"
    "  Prototype:\n"
    "minus(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_times__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_times((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'times'.\n"
    "  Prototype:\n"
    "times(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdivide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_rdivide((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rdivide'.\n"
    "  Prototype:\n"
    "rdivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldivide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_ldivide((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldivide'.\n"
    "  Prototype:\n"
    "ldivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_lt((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lt'.\n"
    "  Prototype:\n"
    "lt(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_le__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_le((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'le'.\n"
    "  Prototype:\n"
    "le(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_gt((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gt'.\n"
    "  Prototype:\n"
    "gt(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_ge((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ge'.\n"
    "  Prototype:\n"
    "ge(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_eq((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eq'.\n"
    "  Prototype:\n"
    "eq(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ne__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_ne((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ne'.\n"
    "  Prototype:\n"
    "ne(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_and__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_and((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_and'.\n"
    "  Prototype:\n"
    "logic_and(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_or__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_or((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_or'.\n"
    "  Prototype:\n"
    "logic_or(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_not__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_not((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_not'.\n"
    "  Prototype:\n"
    "logic_not(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fabs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_abs((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fabs'.\n"
    "  Prototype:\n"
    "fabs(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sqrt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sqrt((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sqrt'.\n"
    "  Prototype:\n"
    "sqrt(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sin((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sin'.\n"
    "  Prototype:\n"
    "sin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cos__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_cos((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cos'.\n"
    "  Prototype:\n"
    "cos(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_tan((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tan'.\n"
    "  Prototype:\n"
    "tan(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_atan((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan'.\n"
    "  Prototype:\n"
    "atan(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_asin((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asin'.\n"
    "  Prototype:\n"
    "asin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acos__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_acos((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acos'.\n"
    "  Prototype:\n"
    "acos(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tanh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_tanh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tanh'.\n"
    "  Prototype:\n"
    "tanh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sinh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sinh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sinh'.\n"
    "  Prototype:\n"
    "sinh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_cosh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cosh'.\n"
    "  Prototype:\n"
    "cosh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atanh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_atanh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atanh'.\n"
    "  Prototype:\n"
    "atanh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asinh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_asinh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asinh'.\n"
    "  Prototype:\n"
    "asinh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acosh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_acosh((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acosh'.\n"
    "  Prototype:\n"
    "acosh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_exp((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'exp'.\n"
    "  Prototype:\n"
    "exp(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_log((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log'.\n"
    "  Prototype:\n"
    "log(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log10__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_log10((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log10'.\n"
    "  Prototype:\n"
    "log10(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log1p__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_log1p((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log1p'.\n"
    "  Prototype:\n"
    "log1p(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_expm1((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm1'.\n"
    "  Prototype:\n"
    "expm1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_floor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_floor((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'floor'.\n"
    "  Prototype:\n"
    "floor(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ceil__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_ceil((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ceil'.\n"
    "  Prototype:\n"
    "ceil(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_erf((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erf'.\n"
    "  Prototype:\n"
    "erf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erfinv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_erfinv((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erfinv'.\n"
    "  Prototype:\n"
    "erfinv(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sign((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sign'.\n"
    "  Prototype:\n"
    "sign(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_power__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_power((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'power'.\n"
    "  Prototype:\n"
    "power(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_fmod((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmod'.\n"
    "  Prototype:\n"
    "fmod(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_remainder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_remainder((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'remainder'.\n"
    "  Prototype:\n"
    "remainder(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_atan2((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan2'.\n"
    "  Prototype:\n"
    "atan2(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_fmin((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmin'.\n"
    "  Prototype:\n"
    "fmin(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_fmax((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmax'.\n"
    "  Prototype:\n"
    "fmax(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hypot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_hypot((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hypot'.\n"
    "  Prototype:\n"
    "hypot(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_simplify((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'simplify'.\n"
    "  Prototype:\n"
    "simplify(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_equal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (bool)casadi::casadi_is_equal((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_equal'.\n"
    "  Prototype:\n"
    "is_equal(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_copysign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_copysign((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'copysign'.\n"
    "  Prototype:\n"
    "copysign(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_constpow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_constpow((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'constpow'.\n"
    "  Prototype:\n"
    "constpow(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_plus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_plus((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'plus'.\n"
    "  Prototype:\n"
    "plus(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_minus((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minus'.\n"
    "  Prototype:\n"
    "minus(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_times__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_times((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'times'.\n"
    "  Prototype:\n"
    "times(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdivide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_rdivide((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rdivide'.\n"
    "  Prototype:\n"
    "rdivide(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldivide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_ldivide((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldivide'.\n"
    "  Prototype:\n"
    "ldivide(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_lt((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lt'.\n"
    "  Prototype:\n"
    "lt(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_le__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_le((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'le'.\n"
    "  Prototype:\n"
    "le(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_gt((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gt'.\n"
    "  Prototype:\n"
    "gt(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_ge((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ge'.\n"
    "  Prototype:\n"
    "ge(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_eq((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eq'.\n"
    "  Prototype:\n"
    "eq(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ne__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_ne((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ne'.\n"
    "  Prototype:\n"
    "ne(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_and__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_and((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_and'.\n"
    "  Prototype:\n"
    "logic_and(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_or__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_or((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_or'.\n"
    "  Prototype:\n"
    "logic_or(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_not__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_not((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_not'.\n"
    "  Prototype:\n"
    "logic_not(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fabs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_abs((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fabs'.\n"
    "  Prototype:\n"
    "fabs(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sqrt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sqrt((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sqrt'.\n"
    "  Prototype:\n"
    "sqrt(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sin((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sin'.\n"
    "  Prototype:\n"
    "sin(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cos__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_cos((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cos'.\n"
    "  Prototype:\n"
    "cos(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_tan((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tan'.\n"
    "  Prototype:\n"
    "tan(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_atan((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan'.\n"
    "  Prototype:\n"
    "atan(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_asin((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asin'.\n"
    "  Prototype:\n"
    "asin(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acos__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_acos((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acos'.\n"
    "  Prototype:\n"
    "acos(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tanh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_tanh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tanh'.\n"
    "  Prototype:\n"
    "tanh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sinh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sinh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sinh'.\n"
    "  Prototype:\n"
    "sinh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_cosh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cosh'.\n"
    "  Prototype:\n"
    "cosh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atanh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_atanh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atanh'.\n"
    "  Prototype:\n"
    "atanh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asinh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_asinh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asinh'.\n"
    "  Prototype:\n"
    "asinh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acosh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_acosh((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acosh'.\n"
    "  Prototype:\n"
    "acosh(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_exp((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'exp'.\n"
    "  Prototype:\n"
    "exp(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_log((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log'.\n"
    "  Prototype:\n"
    "log(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log10__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_log10((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log10'.\n"
    "  Prototype:\n"
    "log10(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log1p__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_log1p((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log1p'.\n"
    "  Prototype:\n"
    "log1p(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_expm1((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm1'.\n"
    "  Prototype:\n"
    "expm1(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_floor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_floor((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'floor'.\n"
    "  Prototype:\n"
    "floor(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ceil__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_ceil((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ceil'.\n"
    "  Prototype:\n"
    "ceil(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_erf((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erf'.\n"
    "  Prototype:\n"
    "erf(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erfinv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_erfinv((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erfinv'.\n"
    "  Prototype:\n"
    "erfinv(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sign((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sign'.\n"
    "  Prototype:\n"
    "sign(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_power__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_power((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'power'.\n"
    "  Prototype:\n"
    "power(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_fmod((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmod'.\n"
    "  Prototype:\n"
    "fmod(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_remainder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_remainder((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'remainder'.\n"
    "  Prototype:\n"
    "remainder(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_atan2((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan2'.\n"
    "  Prototype:\n"
    "atan2(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_fmin((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmin'.\n"
    "  Prototype:\n"
    "fmin(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_fmax((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmax'.\n"
    "  Prototype:\n"
    "fmax(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hypot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_hypot((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hypot'.\n"
    "  Prototype:\n"
    "hypot(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_simplify((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'simplify'.\n"
    "  Prototype:\n"
    "simplify(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_equal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (bool)casadi::casadi_is_equal((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_equal'.\n"
    "  Prototype:\n"
    "is_equal(DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_copysign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_copysign((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'copysign'.\n"
    "  Prototype:\n"
    "copysign(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_constpow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_constpow((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'constpow'.\n"
    "  Prototype:\n"
    "constpow(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_plus__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_plus((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'plus'.\n"
    "  Prototype:\n"
    "plus(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minus__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_minus((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minus'.\n"
    "  Prototype:\n"
    "minus(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_times__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_times((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'times'.\n"
    "  Prototype:\n"
    "times(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdivide__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_rdivide((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rdivide'.\n"
    "  Prototype:\n"
    "rdivide(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldivide__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_ldivide((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldivide'.\n"
    "  Prototype:\n"
    "ldivide(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_lt((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lt'.\n"
    "  Prototype:\n"
    "lt(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_le__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_le((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'le'.\n"
    "  Prototype:\n"
    "le(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_gt((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gt'.\n"
    "  Prototype:\n"
    "gt(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_ge((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ge'.\n"
    "  Prototype:\n"
    "ge(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eq__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_eq((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eq'.\n"
    "  Prototype:\n"
    "eq(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ne__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_ne((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ne'.\n"
    "  Prototype:\n"
    "ne(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_and__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_and((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_and'.\n"
    "  Prototype:\n"
    "logic_and(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_or__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_or((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_or'.\n"
    "  Prototype:\n"
    "logic_or(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_not__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_not((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_not'.\n"
    "  Prototype:\n"
    "logic_not(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fabs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_abs((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fabs'.\n"
    "  Prototype:\n"
    "fabs(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sqrt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sqrt((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sqrt'.\n"
    "  Prototype:\n"
    "sqrt(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sin((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sin'.\n"
    "  Prototype:\n"
    "sin(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cos__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_cos((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cos'.\n"
    "  Prototype:\n"
    "cos(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_tan((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tan'.\n"
    "  Prototype:\n"
    "tan(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_atan((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan'.\n"
    "  Prototype:\n"
    "atan(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_asin((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asin'.\n"
    "  Prototype:\n"
    "asin(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acos__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_acos((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acos'.\n"
    "  Prototype:\n"
    "acos(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tanh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_tanh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tanh'.\n"
    "  Prototype:\n"
    "tanh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sinh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sinh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sinh'.\n"
    "  Prototype:\n"
    "sinh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_cosh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cosh'.\n"
    "  Prototype:\n"
    "cosh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atanh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_atanh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atanh'.\n"
    "  Prototype:\n"
    "atanh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asinh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_asinh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asinh'.\n"
    "  Prototype:\n"
    "asinh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acosh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_acosh((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acosh'.\n"
    "  Prototype:\n"
    "acosh(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_exp((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'exp'.\n"
    "  Prototype:\n"
    "exp(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_log((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log'.\n"
    "  Prototype:\n"
    "log(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log10__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_log10((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log10'.\n"
    "  Prototype:\n"
    "log10(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log1p__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_log1p((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log1p'.\n"
    "  Prototype:\n"
    "log1p(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_expm1((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm1'.\n"
    "  Prototype:\n"
    "expm1(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_floor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_floor((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'floor'.\n"
    "  Prototype:\n"
    "floor(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ceil__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_ceil((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ceil'.\n"
    "  Prototype:\n"
    "ceil(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_erf((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erf'.\n"
    "  Prototype:\n"
    "erf(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erfinv__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_erfinv((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erfinv'.\n"
    "  Prototype:\n"
    "erfinv(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sign((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sign'.\n"
    "  Prototype:\n"
    "sign(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_power__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_power((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'power'.\n"
    "  Prototype:\n"
    "power(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmod__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_fmod((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmod'.\n"
    "  Prototype:\n"
    "fmod(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_remainder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_remainder((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'remainder'.\n"
    "  Prototype:\n"
    "remainder(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_atan2((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan2'.\n"
    "  Prototype:\n"
    "atan2(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_fmin((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmin'.\n"
    "  Prototype:\n"
    "fmin(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmax__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_fmax((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmax'.\n"
    "  Prototype:\n"
    "fmax(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hypot__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_hypot((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hypot'.\n"
    "  Prototype:\n"
    "hypot(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_simplify((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'simplify'.\n"
    "  Prototype:\n"
    "simplify(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_equal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (bool)casadi::casadi_is_equal((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_equal'.\n"
    "  Prototype:\n"
    "is_equal(SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_copysign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_copysign((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'copysign'.\n"
    "  Prototype:\n"
    "copysign(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_constpow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_constpow((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'constpow'.\n"
    "  Prototype:\n"
    "constpow(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_plus__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_plus((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'plus'.\n"
    "  Prototype:\n"
    "plus(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_plus(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"plus",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_plus__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_plus__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_plus__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_plus__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_minus__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_minus((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minus'.\n"
    "  Prototype:\n"
    "minus(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minus(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"minus",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_minus__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_minus__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_minus__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_minus__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_times__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_times((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'times'.\n"
    "  Prototype:\n"
    "times(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_times(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"times",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_times__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_times__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_times__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_times__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rdivide__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_rdivide((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rdivide'.\n"
    "  Prototype:\n"
    "rdivide(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdivide(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rdivide",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_rdivide__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_rdivide__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_rdivide__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_rdivide__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ldivide__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_ldivide((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldivide'.\n"
    "  Prototype:\n"
    "ldivide(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldivide(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ldivide",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_ldivide__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_ldivide__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_ldivide__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_ldivide__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ldivide'.\n"
    "  Possible prototypes are:\n"
    "    ldivide(float,float)\n"
    "    ldivide(DM,DM)\n"
    "    ldivide(SX,SX)\n"
    "    ldivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_lt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_lt((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'lt'.\n"
    "  Prototype:\n"
    "lt(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"lt",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_lt__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_lt__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_lt__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_lt__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_le__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_le((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'le'.\n"
    "  Prototype:\n"
    "le(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_le(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"le",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_le__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_le__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_le__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_le__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_gt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_gt((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gt'.\n"
    "  Prototype:\n"
    "gt(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"gt",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_gt__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_gt__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_gt__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_gt__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'gt'.\n"
    "  Possible prototypes are:\n"
    "    gt(float,float)\n"
    "    gt(DM,DM)\n"
    "    gt(SX,SX)\n"
    "    gt(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_ge__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_ge((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ge'.\n"
    "  Prototype:\n"
    "ge(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ge",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_ge__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_ge__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_ge__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_ge__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ge'.\n"
    "  Possible prototypes are:\n"
    "    ge(float,float)\n"
    "    ge(DM,DM)\n"
    "    ge(SX,SX)\n"
    "    ge(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_eq__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_eq((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eq'.\n"
    "  Prototype:\n"
    "eq(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eq(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"eq",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_eq__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_eq__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_eq__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_eq__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ne__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_ne((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ne'.\n"
    "  Prototype:\n"
    "ne(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ne(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ne",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_ne__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_ne__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_ne__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_ne__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_logic_and__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_and((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_and'.\n"
    "  Prototype:\n"
    "logic_and(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_and(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logic_and",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_logic_and__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_logic_and__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_logic_and__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_logic_and__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_logic_or__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_or((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_or'.\n"
    "  Prototype:\n"
    "logic_or(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_or(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logic_or",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_logic_or__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_logic_or__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_logic_or__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_logic_or__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_logic_not__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_not((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_not'.\n"
    "  Prototype:\n"
    "logic_not(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_not(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logic_not",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_logic_not__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_logic_not__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_logic_not__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_logic_not__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'logic_not'.\n"
    "  Possible prototypes are:\n"
    "    logic_not(float)\n"
    "    logic_not(DM)\n"
    "    logic_not(SX)\n"
    "    logic_not(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_fabs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_abs((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fabs'.\n"
    "  Prototype:\n"
    "fabs(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fabs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"fabs",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_fabs__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_fabs__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_fabs__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_fabs__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'fabs'.\n"
    "  Possible prototypes are:\n"
    "    fabs(float)\n"
    "    fabs(DM)\n"
    "    fabs(SX)\n"
    "    fabs(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sqrt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_sqrt((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sqrt'.\n"
    "  Prototype:\n"
    "sqrt(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sqrt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sqrt",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_sqrt__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sqrt__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sqrt__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sqrt__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sqrt'.\n"
    "  Possible prototypes are:\n"
    "    sqrt(float)\n"
    "    sqrt(DM)\n"
    "    sqrt(SX)\n"
    "    sqrt(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_sin((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sin'.\n"
    "  Prototype:\n"
    "sin(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sin",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_sin__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sin__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sin'.\n"
    "  Possible prototypes are:\n"
    "    sin(float)\n"
    "    sin(DM)\n"
    "    sin(SX)\n"
    "    sin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cos__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_cos((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cos'.\n"
    "  Prototype:\n"
    "cos(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cos(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cos",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_cos__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_cos__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_cos__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_cos__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cos'.\n"
    "  Possible prototypes are:\n"
    "    cos(float)\n"
    "    cos(DM)\n"
    "    cos(SX)\n"
    "    cos(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_tan__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_tan((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tan'.\n"
    "  Prototype:\n"
    "tan(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"tan",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_tan__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_tan__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_tan__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_tan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'tan'.\n"
    "  Possible prototypes are:\n"
    "    tan(float)\n"
    "    tan(DM)\n"
    "    tan(SX)\n"
    "    tan(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_atan__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_atan((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan'.\n"
    "  Prototype:\n"
    "atan(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"atan",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_atan__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_atan__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_atan__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_atan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'atan'.\n"
    "  Possible prototypes are:\n"
    "    atan(float)\n"
    "    atan(DM)\n"
    "    atan(SX)\n"
    "    atan(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_asin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_asin((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asin'.\n"
    "  Prototype:\n"
    "asin(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"asin",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_asin__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_asin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_asin__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_asin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'asin'.\n"
    "  Possible prototypes are:\n"
    "    asin(float)\n"
    "    asin(DM)\n"
    "    asin(SX)\n"
    "    asin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_acos__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_acos((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acos'.\n"
    "  Prototype:\n"
    "acos(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acos(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"acos",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_acos__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_acos__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_acos__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_acos__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'acos'.\n"
    "  Possible prototypes are:\n"
    "    acos(float)\n"
    "    acos(DM)\n"
    "    acos(SX)\n"
    "    acos(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_tanh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_tanh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tanh'.\n"
    "  Prototype:\n"
    "tanh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tanh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"tanh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_tanh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_tanh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_tanh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_tanh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'tanh'.\n"
    "  Possible prototypes are:\n"
    "    tanh(float)\n"
    "    tanh(DM)\n"
    "    tanh(SX)\n"
    "    tanh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sinh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_sinh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sinh'.\n"
    "  Prototype:\n"
    "sinh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sinh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sinh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_sinh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sinh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sinh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sinh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sinh'.\n"
    "  Possible prototypes are:\n"
    "    sinh(float)\n"
    "    sinh(DM)\n"
    "    sinh(SX)\n"
    "    sinh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cosh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_cosh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cosh'.\n"
    "  Prototype:\n"
    "cosh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cosh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_cosh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_cosh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_cosh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_cosh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cosh'.\n"
    "  Possible prototypes are:\n"
    "    cosh(float)\n"
    "    cosh(DM)\n"
    "    cosh(SX)\n"
    "    cosh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_atanh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_atanh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atanh'.\n"
    "  Prototype:\n"
    "atanh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atanh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"atanh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_atanh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_atanh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_atanh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_atanh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'atanh'.\n"
    "  Possible prototypes are:\n"
    "    atanh(float)\n"
    "    atanh(DM)\n"
    "    atanh(SX)\n"
    "    atanh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_asinh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_asinh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'asinh'.\n"
    "  Prototype:\n"
    "asinh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_asinh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"asinh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_asinh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_asinh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_asinh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_asinh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'asinh'.\n"
    "  Possible prototypes are:\n"
    "    asinh(float)\n"
    "    asinh(DM)\n"
    "    asinh(SX)\n"
    "    asinh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_acosh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_acosh((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'acosh'.\n"
    "  Prototype:\n"
    "acosh(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_acosh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"acosh",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_acosh__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_acosh__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_acosh__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_acosh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'acosh'.\n"
    "  Possible prototypes are:\n"
    "    acosh(float)\n"
    "    acosh(DM)\n"
    "    acosh(SX)\n"
    "    acosh(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_exp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_exp((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'exp'.\n"
    "  Prototype:\n"
    "exp(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"exp",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_exp__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_exp__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_exp__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_exp__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'exp'.\n"
    "  Possible prototypes are:\n"
    "    exp(float)\n"
    "    exp(DM)\n"
    "    exp(SX)\n"
    "    exp(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_log__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_log((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log'.\n"
    "  Prototype:\n"
    "log(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"log",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_log__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_log__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_log__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_log__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'log'.\n"
    "  Possible prototypes are:\n"
    "    log(float)\n"
    "    log(DM)\n"
    "    log(SX)\n"
    "    log(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_log10__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_log10((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log10'.\n"
    "  Prototype:\n"
    "log10(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log10(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"log10",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_log10__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_log10__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_log10__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_log10__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'log10'.\n"
    "  Possible prototypes are:\n"
    "    log10(float)\n"
    "    log10(DM)\n"
    "    log10(SX)\n"
    "    log10(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_log1p__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_log1p((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'log1p'.\n"
    "  Prototype:\n"
    "log1p(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log1p(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"log1p",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_log1p__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_log1p__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_log1p__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_log1p__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'log1p'.\n"
    "  Possible prototypes are:\n"
    "    log1p(float)\n"
    "    log1p(DM)\n"
    "    log1p(SX)\n"
    "    log1p(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_expm1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_expm1((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm1'.\n"
    "  Prototype:\n"
    "expm1(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"expm1",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_expm1__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_expm1__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_expm1__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_expm1__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'expm1'.\n"
    "  Possible prototypes are:\n"
    "    expm1(float)\n"
    "    expm1(DM)\n"
    "    expm1(SX)\n"
    "    expm1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_floor__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_floor((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'floor'.\n"
    "  Prototype:\n"
    "floor(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_floor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"floor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_floor__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_floor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_floor__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_floor__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'floor'.\n"
    "  Possible prototypes are:\n"
    "    floor(float)\n"
    "    floor(DM)\n"
    "    floor(SX)\n"
    "    floor(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_ceil__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_ceil((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ceil'.\n"
    "  Prototype:\n"
    "ceil(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ceil(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ceil",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_ceil__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_ceil__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_ceil__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_ceil__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ceil'.\n"
    "  Possible prototypes are:\n"
    "    ceil(float)\n"
    "    ceil(DM)\n"
    "    ceil(SX)\n"
    "    ceil(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_erf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_erf((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erf'.\n"
    "  Prototype:\n"
    "erf(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"erf",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_erf__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_erf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_erf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_erf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'erf'.\n"
    "  Possible prototypes are:\n"
    "    erf(float)\n"
    "    erf(DM)\n"
    "    erf(SX)\n"
    "    erf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_erfinv__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_erfinv((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'erfinv'.\n"
    "  Prototype:\n"
    "erfinv(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erfinv(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"erfinv",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_erfinv__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_erfinv__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_erfinv__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_erfinv__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'erfinv'.\n"
    "  Possible prototypes are:\n"
    "    erfinv(float)\n"
    "    erfinv(DM)\n"
    "    erfinv(SX)\n"
    "    erfinv(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sign__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_sign((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sign'.\n"
    "  Prototype:\n"
    "sign(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sign(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sign",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_sign__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sign__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sign__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sign__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sign'.\n"
    "  Possible prototypes are:\n"
    "    sign(float)\n"
    "    sign(DM)\n"
    "    sign(SX)\n"
    "    sign(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_power__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_power((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'power'.\n"
    "  Prototype:\n"
    "power(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_power(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"power",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_power__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_power__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_power__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_power__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_fmod__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_fmod((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmod'.\n"
    "  Prototype:\n"
    "fmod(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmod(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"fmod",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_fmod__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_fmod__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_fmod__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_fmod__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'fmod'.\n"
    "  Possible prototypes are:\n"
    "    fmod(float,float)\n"
    "    fmod(DM,DM)\n"
    "    fmod(SX,SX)\n"
    "    fmod(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_remainder__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_remainder((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'remainder'.\n"
    "  Prototype:\n"
    "remainder(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_remainder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"remainder",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_remainder__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_remainder__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_remainder__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_remainder__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'remainder'.\n"
    "  Possible prototypes are:\n"
    "    remainder(float,float)\n"
    "    remainder(DM,DM)\n"
    "    remainder(SX,SX)\n"
    "    remainder(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_atan2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_atan2((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'atan2'.\n"
    "  Prototype:\n"
    "atan2(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_atan2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"atan2",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_atan2__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_atan2__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_atan2__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_atan2__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_fmin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_fmin((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmin'.\n"
    "  Prototype:\n"
    "fmin(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"fmin",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_fmin__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_fmin__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_fmin__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_fmin__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'fmin'.\n"
    "  Possible prototypes are:\n"
    "    fmin(float,float)\n"
    "    fmin(DM,DM)\n"
    "    fmin(SX,SX)\n"
    "    fmin(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_fmax__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_fmax((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'fmax'.\n"
    "  Prototype:\n"
    "fmax(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fmax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"fmax",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_fmax__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_fmax__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_fmax__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_fmax__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'fmax'.\n"
    "  Possible prototypes are:\n"
    "    fmax(float,float)\n"
    "    fmax(DM,DM)\n"
    "    fmax(SX,SX)\n"
    "    fmax(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_hypot__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_hypot((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hypot'.\n"
    "  Prototype:\n"
    "hypot(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hypot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"hypot",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_hypot__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_hypot__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_hypot__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_hypot__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'hypot'.\n"
    "  Possible prototypes are:\n"
    "    hypot(float,float)\n"
    "    hypot(DM,DM)\n"
    "    hypot(SX,SX)\n"
    "    hypot(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_simplify__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double m1 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_simplify((double const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'simplify'.\n"
    "  Prototype:\n"
    "simplify(float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"simplify",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      return _wrap_simplify__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_simplify__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_simplify__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_simplify__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'simplify'.\n"
    "  Possible prototypes are:\n"
    "    simplify(float)\n"
    "    simplify(DM)\n"
    "    simplify(SX)\n"
    "    simplify(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_is_equal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 0 ;
  double m1 ;
  double m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (bool)casadi::casadi_is_equal((double const &)*arg1,(double const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_equal'.\n"
    "  Prototype:\n"
    "is_equal(float,float,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_equal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"is_equal",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_is_equal__SWIG_3(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_is_equal__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_is_equal__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_is_equal__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_is_equal__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_is_equal__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_is_equal__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_is_equal__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'is_equal'.\n"
    "  Possible prototypes are:\n"
    "    is_equal(float,float,int)\n"
    "    is_equal(DM,DM,int)\n"
    "    is_equal(SX,SX,int)\n"
    "    is_equal(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_copysign__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_copysign((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'copysign'.\n"
    "  Prototype:\n"
    "copysign(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_copysign(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"copysign",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_copysign__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_copysign__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_copysign__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_copysign__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_constpow__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double m1 ;
  double m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "float" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      result = (double)casadi::casadi_constpow((double const &)*arg1,(double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'constpow'.\n"
    "  Prototype:\n"
    "constpow(float,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_constpow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"constpow",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< double **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_constpow__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_constpow__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_constpow__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_constpow__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mpower__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mpower((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mpower'.\n"
    "  Prototype:\n"
    "mpower(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mrdivide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mrdivide((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mrdivide'.\n"
    "  Prototype:\n"
    "mrdivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mldivide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mldivide((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mldivide'.\n"
    "  Prototype:\n"
    "mldivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_symvar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_symvar((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'symvar'.\n"
    "  Prototype:\n"
    "symvar(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rank1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  casadi::MX result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_rank1((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rank1'.\n"
    "  Prototype:\n"
    "rank1(MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sumsqr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_sumsqr((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sumsqr'.\n"
    "  Prototype:\n"
    "sumsqr(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linspace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_int arg3 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_linspace((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linspace'.\n"
    "  Prototype:\n"
    "linspace(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interp1d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::string const &arg4_defvalue = "linear" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  bool arg5 = (bool) false ;
  std::vector< double > m1 ;
  casadi::MX m2 ;
  std::vector< double > m3 ;
  std::string m4 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_interp1d((std::vector< double,std::allocator< double > > const &)*arg1,(casadi::MX const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::string const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interp1d'.\n"
    "  Prototype:\n"
    "interp1d([float],MX,[float],str,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_soc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_soc((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'soc'.\n"
    "  Prototype:\n"
    "soc(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cross((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cross'.\n"
    "  Prototype:\n"
    "cross(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_skew__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_skew((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'skew'.\n"
    "  Prototype:\n"
    "skew(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_skew__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_inv_skew((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_skew'.\n"
    "  Prototype:\n"
    "inv_skew(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_det__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_det((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'det'.\n"
    "  Prototype:\n"
    "det(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_minor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_inv_minor((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_minor'.\n"
    "  Prototype:\n"
    "inv_minor(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_inv((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::MX m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_inv((casadi::MX const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_trace((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'trace'.\n"
    "  Prototype:\n"
    "trace(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril2symm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_tril2symm((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril2symm'.\n"
    "  Prototype:\n"
    "tril2symm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu2symm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_triu2symm((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu2symm'.\n"
    "  Prototype:\n"
    "triu2symm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_fro__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_norm_fro((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_fro'.\n"
    "  Prototype:\n"
    "norm_fro(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_norm_2((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_2'.\n"
    "  Prototype:\n"
    "norm_2(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_norm_1((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_1'.\n"
    "  Prototype:\n"
    "norm_1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_inf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_norm_inf((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_inf'.\n"
    "  Prototype:\n"
    "norm_inf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_dot((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dot'.\n"
    "  Prototype:\n"
    "dot(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nullspace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_nullspace((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nullspace'.\n"
    "  Prototype:\n"
    "nullspace(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_polyval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_polyval((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'polyval'.\n"
    "  Prototype:\n"
    "polyval(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_diag((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diag'.\n"
    "  Prototype:\n"
    "diag(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_unite((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'unite'.\n"
    "  Prototype:\n"
    "unite(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_densify__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_densify((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'densify'.\n"
    "  Prototype:\n"
    "densify(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_project__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  bool arg3 = (bool) false ;
  casadi::MX m1 ;
  casadi::Sparsity m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_project((casadi::MX const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'project'.\n"
    "  Prototype:\n"
    "project(MX,Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_if_else__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_if_else((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'if_else'.\n"
    "  Prototype:\n"
    "if_else(MX,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conditional__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::MX m1 ;
  std::vector< casadi::MX > m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_conditional((casadi::MX const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(casadi::MX const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conditional'.\n"
    "  Prototype:\n"
    "conditional(MX,[MX],MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_depends_on__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (bool)casadi::casadi_depends_on((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'depends_on'.\n"
    "  Prototype:\n"
    "depends_on(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_solve((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_solve((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(MX,MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_pinv((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::MX m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_pinv((casadi::MX const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm_const__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_expm_const((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm_const'.\n"
    "  Prototype:\n"
    "expm_const(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_expm((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm'.\n"
    "  Prototype:\n"
    "expm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_jacobian((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian'.\n"
    "  Prototype:\n"
    "jacobian(MX,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jtimes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_jtimes((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jtimes'.\n"
    "  Prototype:\n"
    "jtimes(MX,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linearize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_linearize((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linearize'.\n"
    "  Prototype:\n"
    "linearize(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_which_depends__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 1 ;
  bool arg4 = (bool) false ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_which_depends((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'which_depends'.\n"
    "  Prototype:\n"
    "which_depends(MX,MX,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian_sparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_jacobian_sparsity((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian_sparsity'.\n"
    "  Prototype:\n"
    "jacobian_sparsity(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_linear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_linear((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_linear'.\n"
    "  Prototype:\n"
    "is_linear(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_quadratic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_quadratic((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_quadratic'.\n"
    "  Prototype:\n"
    "is_quadratic(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gradient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_gradient((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gradient'.\n"
    "  Prototype:\n"
    "gradient(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tangent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_tangent((casadi::MX const &)*arg1,(casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tangent'.\n"
    "  Prototype:\n"
    "tangent(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hessian__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::MX result;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_hessian((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hessian'.\n"
    "  Prototype:\n"
    "hessian(MX,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_quadratic_coeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  bool arg6 = (bool) true ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  casadi::MX m5 ;
  
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_quadratic_coeff((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,*arg3,*arg4,*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'quadratic_coeff'.\n"
    "  Prototype:\n"
    "quadratic_coeff(MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_coeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  bool arg5 = (bool) true ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_linear_coeff((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linear_coeff'.\n"
    "  Prototype:\n"
    "linear_coeff(MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_n_nodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_n_nodes((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'n_nodes'.\n"
    "  Prototype:\n"
    "n_nodes(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  casadi::MX m1 ;
  std::vector< std::string > m2 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = casadi::casadi_print_operator((casadi::MX const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'print_operator'.\n"
    "  Prototype:\n"
    "print_operator(MX,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repsum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repsum((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repsum'.\n"
    "  Prototype:\n"
    "repsum(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_index arg3 = (casadi_index) -1 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diff((casadi::MX const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diff'.\n"
    "  Prototype:\n"
    "diff(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cumsum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_index arg2 = (casadi_index) -1 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cumsum((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cumsum'.\n"
    "  Prototype:\n"
    "cumsum(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg9 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  std::vector< casadi_int > m9 ;
  casadi::MX result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  arg9 = &m9;
  if (!casadi::to_ptr(swig_obj[8], &arg9)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 9 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8,(std::vector< long long,std::allocator< long long > > const &)*arg9);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(MX,MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  casadi::MX result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mmin((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmin'.\n"
    "  Prototype:\n"
    "mmin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_mmax((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmax'.\n"
    "  Prototype:\n"
    "mmax(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_evalf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::DM result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_evalf((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'evalf'.\n"
    "  Prototype:\n"
    "evalf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_cse((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_cse((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_forward__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< std::vector< casadi::MX > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "MX" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_forward((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'forward'.\n"
    "  Prototype:\n"
    "forward([MX],[MX],[[MX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reverse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< std::vector< casadi::MX > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "MX" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_reverse((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "MX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reverse'.\n"
    "  Prototype:\n"
    "reverse([MX],[MX],[[MX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_substitute((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_substitute((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute([MX],[MX],[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute_inplace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "MX" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_substitute_inplace((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,*arg2,*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute_inplace'.\n"
    "  Prototype:\n"
    "substitute_inplace([MX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_extract__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      casadi::casadi_extract((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,*arg2,*arg3,*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'extract'.\n"
    "  Prototype:\n"
    "extract([MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_shared__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg4 = 0 ;
  std::string const &arg5_defvalue = "v_" ;
  std::string *arg5 = (std::string *) &arg5_defvalue ;
  std::string const &arg6_defvalue = "" ;
  std::string *arg6 = (std::string *) &arg6_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX > m4 ;
  std::string m5 ;
  std::string m6 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "str" "'.");
  }
  {
    try {
      casadi::casadi_shared((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,*arg2,*arg3,*arg4,(std::string const &)*arg5,(std::string const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'shared'.\n"
    "  Prototype:\n"
    "shared([MX],str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > *arg1 = 0 ;
  std::vector< std::vector< casadi::MX > > m1 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "[" "MX" "]" "]" "'.");
  {
    try {
      result = casadi::casadi_blockcat((std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat([[MX]])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mpower__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mpower((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mpower'.\n"
    "  Prototype:\n"
    "mpower(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mrdivide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mrdivide((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mrdivide'.\n"
    "  Prototype:\n"
    "mrdivide(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mldivide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mldivide((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mldivide'.\n"
    "  Prototype:\n"
    "mldivide(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_symvar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_symvar((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'symvar'.\n"
    "  Prototype:\n"
    "symvar(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rank1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_rank1((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(casadi::Matrix< double > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rank1'.\n"
    "  Prototype:\n"
    "rank1(DM,DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sumsqr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_sumsqr((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sumsqr'.\n"
    "  Prototype:\n"
    "sumsqr(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linspace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi_int arg3 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_linspace((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linspace'.\n"
    "  Prototype:\n"
    "linspace(DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interp1d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::string const &arg4_defvalue = "linear" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  bool arg5 = (bool) false ;
  std::vector< double > m1 ;
  casadi::Matrix< double > m2 ;
  std::vector< double > m3 ;
  std::string m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_interp1d((std::vector< double,std::allocator< double > > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::string const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interp1d'.\n"
    "  Prototype:\n"
    "interp1d([float],DM,[float],str,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_soc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_soc((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'soc'.\n"
    "  Prototype:\n"
    "soc(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cross((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cross'.\n"
    "  Prototype:\n"
    "cross(DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_skew__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_skew((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'skew'.\n"
    "  Prototype:\n"
    "skew(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_skew__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_inv_skew((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_skew'.\n"
    "  Prototype:\n"
    "inv_skew(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_det__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_det((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'det'.\n"
    "  Prototype:\n"
    "det(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_minor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_inv_minor((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_minor'.\n"
    "  Prototype:\n"
    "inv_minor(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_inv((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< double > m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_inv((casadi::Matrix< double > const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(DM,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_trace((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'trace'.\n"
    "  Prototype:\n"
    "trace(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril2symm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_tril2symm((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril2symm'.\n"
    "  Prototype:\n"
    "tril2symm(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu2symm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_triu2symm((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu2symm'.\n"
    "  Prototype:\n"
    "triu2symm(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_fro__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_norm_fro((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_fro'.\n"
    "  Prototype:\n"
    "norm_fro(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_norm_2((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_2'.\n"
    "  Prototype:\n"
    "norm_2(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_norm_1((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_1'.\n"
    "  Prototype:\n"
    "norm_1(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_inf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_norm_inf((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_inf'.\n"
    "  Prototype:\n"
    "norm_inf(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_dot((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dot'.\n"
    "  Prototype:\n"
    "dot(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nullspace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_nullspace((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nullspace'.\n"
    "  Prototype:\n"
    "nullspace(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_polyval__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_polyval((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'polyval'.\n"
    "  Prototype:\n"
    "polyval(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_diag((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diag'.\n"
    "  Prototype:\n"
    "diag(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_unite((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'unite'.\n"
    "  Prototype:\n"
    "unite(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_densify__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_densify((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'densify'.\n"
    "  Prototype:\n"
    "densify(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_project__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  bool arg3 = (bool) false ;
  casadi::Matrix< double > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_project((casadi::Matrix< double > const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'project'.\n"
    "  Prototype:\n"
    "project(DM,Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_if_else__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_if_else((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'if_else'.\n"
    "  Prototype:\n"
    "if_else(DM,DM,DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conditional__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< double > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_conditional((casadi::Matrix< double > const &)*arg1,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conditional'.\n"
    "  Prototype:\n"
    "conditional(DM,[DM],DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_depends_on__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (bool)casadi::casadi_depends_on((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'depends_on'.\n"
    "  Prototype:\n"
    "depends_on(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_solve((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_solve((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(DM,DM,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_pinv((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< double > m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_pinv((casadi::Matrix< double > const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(DM,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm_const__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_expm_const((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm_const'.\n"
    "  Prototype:\n"
    "expm_const(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_expm((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm'.\n"
    "  Prototype:\n"
    "expm(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_jacobian((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian'.\n"
    "  Prototype:\n"
    "jacobian(DM,DM,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jtimes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_jtimes((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jtimes'.\n"
    "  Prototype:\n"
    "jtimes(DM,DM,DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linearize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_linearize((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linearize'.\n"
    "  Prototype:\n"
    "linearize(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_which_depends__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 1 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_which_depends((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'which_depends'.\n"
    "  Prototype:\n"
    "which_depends(DM,DM,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian_sparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_jacobian_sparsity((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian_sparsity'.\n"
    "  Prototype:\n"
    "jacobian_sparsity(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_linear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_linear((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_linear'.\n"
    "  Prototype:\n"
    "is_linear(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_quadratic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_quadratic((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_quadratic'.\n"
    "  Prototype:\n"
    "is_quadratic(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gradient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_gradient((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gradient'.\n"
    "  Prototype:\n"
    "gradient(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tangent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_tangent((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tangent'.\n"
    "  Prototype:\n"
    "tangent(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hessian__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Matrix< double > result;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_hessian((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hessian'.\n"
    "  Prototype:\n"
    "hessian(DM,DM,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_quadratic_coeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  casadi::Matrix< double > *arg5 = 0 ;
  bool arg6 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  casadi::Matrix< double > m5 ;
  
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_quadratic_coeff((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,*arg3,*arg4,*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'quadratic_coeff'.\n"
    "  Prototype:\n"
    "quadratic_coeff(DM,DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_coeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  bool arg5 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_linear_coeff((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linear_coeff'.\n"
    "  Prototype:\n"
    "linear_coeff(DM,DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_n_nodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_n_nodes((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'n_nodes'.\n"
    "  Prototype:\n"
    "n_nodes(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_operator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  std::vector< std::string > m2 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = casadi::casadi_print_operator((casadi::Matrix< double > const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'print_operator'.\n"
    "  Prototype:\n"
    "print_operator(DM,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repsum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repsum((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repsum'.\n"
    "  Prototype:\n"
    "repsum(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_index arg3 = (casadi_index) -1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diff((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diff'.\n"
    "  Prototype:\n"
    "diff(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cumsum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_index arg2 = (casadi_index) -1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cumsum((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cumsum'.\n"
    "  Prototype:\n"
    "cumsum(DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg9 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  std::vector< casadi_int > m9 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  arg9 = &m9;
  if (!casadi::to_ptr(swig_obj[8], &arg9)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 9 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8,(std::vector< long long,std::allocator< long long > > const &)*arg9);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(DM,DM,DM,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(DM,DM,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mmin((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmin'.\n"
    "  Prototype:\n"
    "mmin(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_mmax((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmax'.\n"
    "  Prototype:\n"
    "mmax(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_evalf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::DM result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_evalf((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'evalf'.\n"
    "  Prototype:\n"
    "evalf(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_cse((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse([DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_cse((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_forward__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< std::vector< casadi::Matrix< double > > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "DM" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_forward((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2,(std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'forward'.\n"
    "  Prototype:\n"
    "forward([DM],[DM],[[DM]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reverse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< std::vector< casadi::Matrix< double > > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "DM" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_reverse((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2,(std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "DM" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reverse'.\n"
    "  Prototype:\n"
    "reverse([DM],[DM],[[DM]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_substitute((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "DM" "]" "'.");
  {
    try {
      result = casadi::casadi_substitute((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2,(std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute([DM],[DM],[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute_inplace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "DM" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "DM" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_substitute_inplace((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,*arg2,*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute_inplace'.\n"
    "  Prototype:\n"
    "substitute_inplace([DM],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_extract__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  std::vector< casadi::Matrix< double > > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      casadi::casadi_extract((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,*arg2,*arg3,*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'extract'.\n"
    "  Prototype:\n"
    "extract([DM],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_shared__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg4 = 0 ;
  std::string const &arg5_defvalue = "v_" ;
  std::string *arg5 = (std::string *) &arg5_defvalue ;
  std::string const &arg6_defvalue = "" ;
  std::string *arg6 = (std::string *) &arg6_defvalue ;
  std::vector< casadi::Matrix< double > > m1 ;
  std::vector< casadi::Matrix< double > > m2 ;
  std::vector< casadi::Matrix< double > > m3 ;
  std::vector< casadi::Matrix< double > > m4 ;
  std::string m5 ;
  std::string m6 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "DM" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "str" "'.");
  }
  {
    try {
      casadi::casadi_shared((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg1,*arg2,*arg3,*arg4,(std::string const &)*arg5,(std::string const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'shared'.\n"
    "  Prototype:\n"
    "shared([DM],str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > *arg1 = 0 ;
  std::vector< std::vector< casadi::Matrix< double > > > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "[" "DM" "]" "]" "'.");
  {
    try {
      result = casadi::casadi_blockcat((std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat([[DM]])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mpower__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mpower((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mpower'.\n"
    "  Prototype:\n"
    "mpower(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mpower(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mpower",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_mpower__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_mpower__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_mpower__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mpower'.\n"
    "  Possible prototypes are:\n"
    "    mpower(DM,DM)\n"
    "    mpower(SX,SX)\n"
    "    mpower(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mrdivide__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mrdivide((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mrdivide'.\n"
    "  Prototype:\n"
    "mrdivide(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mrdivide(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mrdivide",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_mrdivide__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_mrdivide__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_mrdivide__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mrdivide'.\n"
    "  Possible prototypes are:\n"
    "    mrdivide(DM,DM)\n"
    "    mrdivide(SX,SX)\n"
    "    mrdivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mldivide__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mldivide((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mldivide'.\n"
    "  Prototype:\n"
    "mldivide(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mldivide(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mldivide",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_mldivide__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_mldivide__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_mldivide__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mldivide'.\n"
    "  Possible prototypes are:\n"
    "    mldivide(DM,DM)\n"
    "    mldivide(SX,SX)\n"
    "    mldivide(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_symvar__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_symvar((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'symvar'.\n"
    "  Prototype:\n"
    "symvar(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_symvar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"symvar",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_symvar__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_symvar__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_symvar__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'symvar'.\n"
    "  Possible prototypes are:\n"
    "    symvar(DM)\n"
    "    symvar(SX)\n"
    "    symvar(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_bilin((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bilin'.\n"
    "  Prototype:\n"
    "bilin(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bilin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"bilin",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_bilin__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_bilin__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_bilin__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_bilin__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_bilin__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_bilin__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'bilin'.\n"
    "  Possible prototypes are:\n"
    "    bilin(DM,DM)\n"
    "    bilin(SX,SX)\n"
    "    bilin(MX,MX)\n"
    "    bilin(DM,DM,DM)\n"
    "    bilin(SX,SX,SX)\n"
    "    bilin(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_rank1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_rank1((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rank1'.\n"
    "  Prototype:\n"
    "rank1(SX,SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rank1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rank1",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<double> **>(0));
          if (_v) {
            return _wrap_rank1__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            return _wrap_rank1__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_rank1__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'rank1'.\n"
    "  Possible prototypes are:\n"
    "    rank1(DM,DM,DM,DM)\n"
    "    rank1(SX,SX,SX,SX)\n"
    "    rank1(MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sumsqr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_sumsqr((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sumsqr'.\n"
    "  Prototype:\n"
    "sumsqr(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sumsqr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sumsqr",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_sumsqr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_sumsqr__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_sumsqr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sumsqr'.\n"
    "  Possible prototypes are:\n"
    "    sumsqr(DM)\n"
    "    sumsqr(SX)\n"
    "    sumsqr(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_linspace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi_int arg3 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_linspace((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linspace'.\n"
    "  Prototype:\n"
    "linspace(SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linspace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"linspace",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_linspace__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_linspace__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_linspace__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'linspace'.\n"
    "  Possible prototypes are:\n"
    "    linspace(DM,DM,int)\n"
    "    linspace(SX,SX,int)\n"
    "    linspace(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_logsumexp((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logsumexp'.\n"
    "  Prototype:\n"
    "logsumexp(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logsumexp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logsumexp",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_logsumexp__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_logsumexp__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_logsumexp__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_logsumexp__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_logsumexp__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_logsumexp__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'logsumexp'.\n"
    "  Possible prototypes are:\n"
    "    logsumexp(DM)\n"
    "    logsumexp(SX)\n"
    "    logsumexp(MX)\n"
    "    logsumexp(DM,DM)\n"
    "    logsumexp(SX,SX)\n"
    "    logsumexp(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_interp1d__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::string const &arg4_defvalue = "linear" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  bool arg5 = (bool) false ;
  std::vector< double > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::vector< double > m3 ;
  std::string m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_interp1d((std::vector< double,std::allocator< double > > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::string const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'interp1d'.\n"
    "  Prototype:\n"
    "interp1d([float],SX,[float],str,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_interp1d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"interp1d",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_interp1d__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::string **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interp1d__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_interp1d__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_interp1d__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::string **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interp1d__SWIG_2(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_interp1d__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_interp1d__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::string **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_interp1d__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              return _wrap_interp1d__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'interp1d'.\n"
    "  Possible prototypes are:\n"
    "    interp1d([float],DM,[float],str,bool)\n"
    "    interp1d([float],SX,[float],str,bool)\n"
    "    interp1d([float],MX,[float],str,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_soc__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_soc((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'soc'.\n"
    "  Prototype:\n"
    "soc(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_soc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"soc",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_soc__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_soc__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_soc__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'soc'.\n"
    "  Possible prototypes are:\n"
    "    soc(DM,DM)\n"
    "    soc(SX,SX)\n"
    "    soc(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cross__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cross((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cross'.\n"
    "  Prototype:\n"
    "cross(SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cross",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_cross__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_cross__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_cross__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_cross__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_cross__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_cross__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cross'.\n"
    "  Possible prototypes are:\n"
    "    cross(DM,DM,int)\n"
    "    cross(SX,SX,int)\n"
    "    cross(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_skew__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_skew((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'skew'.\n"
    "  Prototype:\n"
    "skew(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_skew(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"skew",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_skew__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_skew__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_skew__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'skew'.\n"
    "  Possible prototypes are:\n"
    "    skew(DM)\n"
    "    skew(SX)\n"
    "    skew(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_inv_skew__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_inv_skew((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_skew'.\n"
    "  Prototype:\n"
    "inv_skew(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_skew(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"inv_skew",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_inv_skew__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_inv_skew__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_inv_skew__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'inv_skew'.\n"
    "  Possible prototypes are:\n"
    "    inv_skew(DM)\n"
    "    inv_skew(SX)\n"
    "    inv_skew(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_det__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_det((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'det'.\n"
    "  Prototype:\n"
    "det(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_det(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"det",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_det__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_det__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_det__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'det'.\n"
    "  Possible prototypes are:\n"
    "    det(DM)\n"
    "    det(SX)\n"
    "    det(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_inv_minor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_inv_minor((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv_minor'.\n"
    "  Prototype:\n"
    "inv_minor(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_minor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"inv_minor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_inv_minor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_inv_minor__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_inv_minor__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'inv_minor'.\n"
    "  Possible prototypes are:\n"
    "    inv_minor(DM)\n"
    "    inv_minor(SX)\n"
    "    inv_minor(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_inv((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_inv((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'inv'.\n"
    "  Prototype:\n"
    "inv(SX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"inv",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_inv__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_inv__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_inv__SWIG_0(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_inv__SWIG_3(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_inv__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_inv__SWIG_5(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_inv__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_inv__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_inv__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'inv'.\n"
    "  Possible prototypes are:\n"
    "    inv(DM)\n"
    "    inv(SX)\n"
    "    inv(MX)\n"
    "    inv(DM,str,dict)\n"
    "    inv(SX,str,dict)\n"
    "    inv(MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_trace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_trace((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'trace'.\n"
    "  Prototype:\n"
    "trace(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"trace",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_trace__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_trace__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_trace__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'trace'.\n"
    "  Possible prototypes are:\n"
    "    trace(DM)\n"
    "    trace(SX)\n"
    "    trace(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_tril2symm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_tril2symm((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tril2symm'.\n"
    "  Prototype:\n"
    "tril2symm(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tril2symm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"tril2symm",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_tril2symm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_tril2symm__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_tril2symm__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'tril2symm'.\n"
    "  Possible prototypes are:\n"
    "    tril2symm(DM)\n"
    "    tril2symm(SX)\n"
    "    tril2symm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_triu2symm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_triu2symm((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triu2symm'.\n"
    "  Prototype:\n"
    "triu2symm(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triu2symm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"triu2symm",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_triu2symm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_triu2symm__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_triu2symm__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'triu2symm'.\n"
    "  Possible prototypes are:\n"
    "    triu2symm(DM)\n"
    "    triu2symm(SX)\n"
    "    triu2symm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_fro__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_norm_fro((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_fro'.\n"
    "  Prototype:\n"
    "norm_fro(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_fro(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_fro",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_norm_fro__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_norm_fro__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_norm_fro__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_fro'.\n"
    "  Possible prototypes are:\n"
    "    norm_fro(DM)\n"
    "    norm_fro(SX)\n"
    "    norm_fro(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_norm_2((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_2'.\n"
    "  Prototype:\n"
    "norm_2(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_2",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_norm_2__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_norm_2__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_norm_2__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_2'.\n"
    "  Possible prototypes are:\n"
    "    norm_2(DM)\n"
    "    norm_2(SX)\n"
    "    norm_2(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_norm_1((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_1'.\n"
    "  Prototype:\n"
    "norm_1(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_1",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_norm_1__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_norm_1__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_norm_1__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_1'.\n"
    "  Possible prototypes are:\n"
    "    norm_1(DM)\n"
    "    norm_1(SX)\n"
    "    norm_1(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_inf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_norm_inf((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_inf'.\n"
    "  Prototype:\n"
    "norm_inf(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_inf",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_norm_inf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_norm_inf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_norm_inf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_inf'.\n"
    "  Possible prototypes are:\n"
    "    norm_inf(DM)\n"
    "    norm_inf(SX)\n"
    "    norm_inf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dot__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_dot((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dot'.\n"
    "  Prototype:\n"
    "dot(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dot",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_dot__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_dot__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_dot__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dot'.\n"
    "  Possible prototypes are:\n"
    "    dot(DM,DM)\n"
    "    dot(SX,SX)\n"
    "    dot(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_nullspace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_nullspace((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'nullspace'.\n"
    "  Prototype:\n"
    "nullspace(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nullspace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"nullspace",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_nullspace__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_nullspace__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_nullspace__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'nullspace'.\n"
    "  Possible prototypes are:\n"
    "    nullspace(DM)\n"
    "    nullspace(SX)\n"
    "    nullspace(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_polyval__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_polyval((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'polyval'.\n"
    "  Prototype:\n"
    "polyval(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_polyval(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"polyval",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_polyval__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_polyval__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_polyval__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'polyval'.\n"
    "  Possible prototypes are:\n"
    "    polyval(DM,DM)\n"
    "    polyval(SX,SX)\n"
    "    polyval(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_diag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_diag((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diag'.\n"
    "  Prototype:\n"
    "diag(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"diag",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_diag__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_diag__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_diag__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'diag'.\n"
    "  Possible prototypes are:\n"
    "    diag(DM)\n"
    "    diag(SX)\n"
    "    diag(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_unite__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_unite((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'unite'.\n"
    "  Prototype:\n"
    "unite(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unite(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"unite",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_unite__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_unite__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_unite__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'unite'.\n"
    "  Possible prototypes are:\n"
    "    unite(DM,DM)\n"
    "    unite(SX,SX)\n"
    "    unite(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_densify__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_densify((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'densify'.\n"
    "  Prototype:\n"
    "densify(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_densify(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"densify",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_densify__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_densify__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_densify__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'densify'.\n"
    "  Possible prototypes are:\n"
    "    densify(DM)\n"
    "    densify(SX)\n"
    "    densify(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_project__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Sparsity *arg2 = 0 ;
  bool arg3 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Sparsity m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_project((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Sparsity const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'project'.\n"
    "  Prototype:\n"
    "project(SX,Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_project(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"project",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_project__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_project__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_project__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_project__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_project__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_project__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'project'.\n"
    "  Possible prototypes are:\n"
    "    project(DM,Sparsity,bool)\n"
    "    project(SX,Sparsity,bool)\n"
    "    project(MX,Sparsity,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_if_else__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_if_else((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'if_else'.\n"
    "  Prototype:\n"
    "if_else(SX,SX,SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_if_else(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"if_else",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_if_else__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_if_else__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_if_else__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_if_else__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_if_else__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_if_else__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'if_else'.\n"
    "  Possible prototypes are:\n"
    "    if_else(DM,DM,DM,bool)\n"
    "    if_else(SX,SX,SX,bool)\n"
    "    if_else(MX,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_conditional__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_conditional((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'conditional'.\n"
    "  Prototype:\n"
    "conditional(SX,[SX],SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conditional(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"conditional",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_conditional__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_conditional__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_conditional__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_conditional__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_conditional__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_conditional__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'conditional'.\n"
    "  Possible prototypes are:\n"
    "    conditional(DM,[DM],DM,bool)\n"
    "    conditional(SX,[SX],SX,bool)\n"
    "    conditional(MX,[MX],MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_depends_on__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = (bool)casadi::casadi_depends_on((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'depends_on'.\n"
    "  Prototype:\n"
    "depends_on(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_depends_on(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"depends_on",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_depends_on__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_depends_on__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_depends_on__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'depends_on'.\n"
    "  Possible prototypes are:\n"
    "    depends_on(DM,DM)\n"
    "    depends_on(SX,SX)\n"
    "    depends_on(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_solve((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_solve((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'solve'.\n"
    "  Prototype:\n"
    "solve(SX,SX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"solve",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_solve__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_solve__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_solve__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_solve__SWIG_3(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_solve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_solve__SWIG_5(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_solve__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_solve__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_solve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'solve'.\n"
    "  Possible prototypes are:\n"
    "    solve(DM,DM)\n"
    "    solve(SX,SX)\n"
    "    solve(MX,MX)\n"
    "    solve(DM,DM,str,dict)\n"
    "    solve(SX,SX,str,dict)\n"
    "    solve(MX,MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_pinv((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_pinv((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pinv'.\n"
    "  Prototype:\n"
    "pinv(SX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pinv(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"pinv",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_pinv__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_pinv__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_pinv__SWIG_0(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_pinv__SWIG_3(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_pinv__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_pinv__SWIG_5(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_pinv__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_pinv__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_pinv__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'pinv'.\n"
    "  Possible prototypes are:\n"
    "    pinv(DM)\n"
    "    pinv(SX)\n"
    "    pinv(MX)\n"
    "    pinv(DM,str,dict)\n"
    "    pinv(SX,str,dict)\n"
    "    pinv(MX,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_expm_const__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_expm_const((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm_const'.\n"
    "  Prototype:\n"
    "expm_const(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm_const(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"expm_const",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_expm_const__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_expm_const__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_expm_const__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'expm_const'.\n"
    "  Possible prototypes are:\n"
    "    expm_const(DM,DM)\n"
    "    expm_const(SX,SX)\n"
    "    expm_const(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_expm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_expm((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expm'.\n"
    "  Prototype:\n"
    "expm(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"expm",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_expm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_expm__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_expm__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'expm'.\n"
    "  Possible prototypes are:\n"
    "    expm(DM)\n"
    "    expm(SX)\n"
    "    expm(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_jacobian__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_jacobian((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian'.\n"
    "  Prototype:\n"
    "jacobian(SX,SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"jacobian",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_jacobian__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_jacobian__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_jacobian__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_jacobian__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_jacobian__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_jacobian__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'jacobian'.\n"
    "  Possible prototypes are:\n"
    "    jacobian(DM,DM,dict)\n"
    "    jacobian(SX,SX,dict)\n"
    "    jacobian(MX,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_jtimes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_jtimes((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jtimes'.\n"
    "  Prototype:\n"
    "jtimes(SX,SX,SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jtimes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"jtimes",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_jtimes__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_jtimes__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_jtimes__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_jtimes__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_jtimes__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_jtimes__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'jtimes'.\n"
    "  Possible prototypes are:\n"
    "    jtimes(DM,DM,DM,bool)\n"
    "    jtimes(SX,SX,SX,bool)\n"
    "    jtimes(MX,MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_linearize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_linearize((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linearize'.\n"
    "  Prototype:\n"
    "linearize(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linearize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"linearize",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_linearize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_linearize__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_linearize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'linearize'.\n"
    "  Possible prototypes are:\n"
    "    linearize(DM,DM,DM)\n"
    "    linearize(SX,SX,SX)\n"
    "    linearize(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_which_depends__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 1 ;
  bool arg4 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_which_depends((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'which_depends'.\n"
    "  Prototype:\n"
    "which_depends(SX,SX,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_which_depends(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"which_depends",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_which_depends__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_which_depends__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_which_depends__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_which_depends__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_which_depends__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_which_depends__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_which_depends__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_which_depends__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_which_depends__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'which_depends'.\n"
    "  Possible prototypes are:\n"
    "    which_depends(DM,DM,int,bool)\n"
    "    which_depends(SX,SX,int,bool)\n"
    "    which_depends(MX,MX,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_jacobian_sparsity__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Sparsity result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_jacobian_sparsity((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'jacobian_sparsity'.\n"
    "  Prototype:\n"
    "jacobian_sparsity(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_jacobian_sparsity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"jacobian_sparsity",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_jacobian_sparsity__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_jacobian_sparsity__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_jacobian_sparsity__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'jacobian_sparsity'.\n"
    "  Possible prototypes are:\n"
    "    jacobian_sparsity(DM,DM)\n"
    "    jacobian_sparsity(SX,SX)\n"
    "    jacobian_sparsity(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_is_linear__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_linear((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_linear'.\n"
    "  Prototype:\n"
    "is_linear(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_linear(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"is_linear",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_is_linear__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_is_linear__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_is_linear__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'is_linear'.\n"
    "  Possible prototypes are:\n"
    "    is_linear(DM,DM)\n"
    "    is_linear(SX,SX)\n"
    "    is_linear(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_is_quadratic__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = (bool)casadi::casadi_is_quadratic((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'is_quadratic'.\n"
    "  Prototype:\n"
    "is_quadratic(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_quadratic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"is_quadratic",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_is_quadratic__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_is_quadratic__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_is_quadratic__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'is_quadratic'.\n"
    "  Possible prototypes are:\n"
    "    is_quadratic(DM,DM)\n"
    "    is_quadratic(SX,SX)\n"
    "    is_quadratic(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_gradient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_gradient((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gradient'.\n"
    "  Prototype:\n"
    "gradient(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gradient(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"gradient",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_gradient__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_gradient__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_gradient__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'gradient'.\n"
    "  Possible prototypes are:\n"
    "    gradient(DM,DM)\n"
    "    gradient(SX,SX)\n"
    "    gradient(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_tangent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_tangent((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'tangent'.\n"
    "  Prototype:\n"
    "tangent(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tangent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"tangent",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_tangent__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_tangent__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_tangent__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'tangent'.\n"
    "  Possible prototypes are:\n"
    "    tangent(DM,DM)\n"
    "    tangent(SX,SX)\n"
    "    tangent(MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_hessian__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  arg3 = &m3;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[2], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_hessian((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'hessian'.\n"
    "  Prototype:\n"
    "hessian(SX,SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hessian(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"hessian",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_hessian__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_hessian__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_hessian__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_hessian__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_hessian__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_hessian__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'hessian'.\n"
    "  Possible prototypes are:\n"
    "    hessian(DM,DM,dict)\n"
    "    hessian(SX,SX,dict)\n"
    "    hessian(MX,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_quadratic_coeff__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg5 = 0 ;
  bool arg6 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > m5 ;
  
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_quadratic_coeff((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,*arg3,*arg4,*arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'quadratic_coeff'.\n"
    "  Prototype:\n"
    "quadratic_coeff(SX,SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_quadratic_coeff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"quadratic_coeff",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_quadratic_coeff__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_quadratic_coeff__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_quadratic_coeff__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_quadratic_coeff__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_quadratic_coeff__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_quadratic_coeff__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'quadratic_coeff'.\n"
    "  Possible prototypes are:\n"
    "    quadratic_coeff(DM,DM,bool)\n"
    "    quadratic_coeff(SX,SX,bool)\n"
    "    quadratic_coeff(MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_linear_coeff__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  bool arg5 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_linear_coeff((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'linear_coeff'.\n"
    "  Prototype:\n"
    "linear_coeff(SX,SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_linear_coeff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"linear_coeff",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_linear_coeff__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_linear_coeff__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_linear_coeff__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_linear_coeff__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_linear_coeff__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< bool **>(0));
        if (_v) {
          return _wrap_linear_coeff__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'linear_coeff'.\n"
    "  Possible prototypes are:\n"
    "    linear_coeff(DM,DM,bool)\n"
    "    linear_coeff(SX,SX,bool)\n"
    "    linear_coeff(MX,MX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_n_nodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi_int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = (casadi_int)casadi::casadi_n_nodes((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'n_nodes'.\n"
    "  Prototype:\n"
    "n_nodes(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_n_nodes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"n_nodes",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_n_nodes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_n_nodes__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_n_nodes__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'n_nodes'.\n"
    "  Possible prototypes are:\n"
    "    n_nodes(DM)\n"
    "    n_nodes(SX)\n"
    "    n_nodes(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_print_operator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  std::vector< std::string > m2 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = casadi::casadi_print_operator((casadi::Matrix< casadi::SXElem > const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'print_operator'.\n"
    "  Prototype:\n"
    "print_operator(SX,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_operator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"print_operator",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_print_operator__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_print_operator__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_print_operator__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'print_operator'.\n"
    "  Possible prototypes are:\n"
    "    print_operator(DM,[str])\n"
    "    print_operator(SX,[str])\n"
    "    print_operator(MX,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_repsum__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_repsum((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'repsum'.\n"
    "  Prototype:\n"
    "repsum(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repsum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"repsum",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repsum__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repsum__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repsum__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repsum__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_repsum__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_repsum__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'repsum'.\n"
    "  Possible prototypes are:\n"
    "    repsum(DM,int,int)\n"
    "    repsum(SX,int,int)\n"
    "    repsum(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_diff__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_index arg3 = (casadi_index) -1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_diff((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'diff'.\n"
    "  Prototype:\n"
    "diff(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"diff",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diff__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_diff__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diff__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diff__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_diff__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diff__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_diff__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_diff__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_diff__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'diff'.\n"
    "  Possible prototypes are:\n"
    "    diff(DM,int,int)\n"
    "    diff(SX,int,int)\n"
    "    diff(MX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cumsum__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_index arg2 = (casadi_index) -1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_cumsum((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cumsum'.\n"
    "  Prototype:\n"
    "cumsum(SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cumsum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cumsum",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_cumsum__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_cumsum__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_cumsum__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_cumsum__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_cumsum__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_cumsum__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cumsum'.\n"
    "  Possible prototypes are:\n"
    "    cumsum(DM,int)\n"
    "    cumsum(SX,int)\n"
    "    cumsum(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg9 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  std::vector< casadi_int > m9 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  arg9 = &m9;
  if (!casadi::to_ptr(swig_obj[8], &arg9)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 9 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8,(std::vector< long long,std::allocator< long long > > const &)*arg9);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(SX,SX,SX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg7 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg8 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::vector< casadi_int > m3 ;
  std::vector< casadi_int > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  std::vector< casadi_int > m7 ;
  std::vector< casadi_int > m8 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  arg7 = &m7;
  if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "[" "int" "]" "'.");
  arg8 = &m8;
  if (!casadi::to_ptr(swig_obj[7], &arg8)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 8 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_einstein((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(std::vector< long long,std::allocator< long long > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,(std::vector< long long,std::allocator< long long > > const &)*arg7,(std::vector< long long,std::allocator< long long > > const &)*arg8);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'einstein'.\n"
    "  Prototype:\n"
    "einstein(SX,SX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_einstein(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"einstein",0,9,argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    return _wrap_einstein__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    return _wrap_einstein__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi_int> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    return _wrap_einstein__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    _v = casadi::to_ptr(argv[8], static_cast< std::vector<casadi_int> **>(0));
                    if (_v) {
                      return _wrap_einstein__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    _v = casadi::to_ptr(argv[8], static_cast< std::vector<casadi_int> **>(0));
                    if (_v) {
                      return _wrap_einstein__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                _v = casadi::to_ptr(argv[6], static_cast< std::vector<casadi_int> **>(0));
                if (_v) {
                  _v = casadi::to_ptr(argv[7], static_cast< std::vector<casadi_int> **>(0));
                  if (_v) {
                    _v = casadi::to_ptr(argv[8], static_cast< std::vector<casadi_int> **>(0));
                    if (_v) {
                      return _wrap_einstein__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'einstein'.\n"
    "  Possible prototypes are:\n"
    "    einstein(DM,DM,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(SX,SX,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(MX,MX,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(DM,DM,DM,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(SX,SX,SX,[int],[int],[int],[int],[int],[int])\n"
    "    einstein(MX,MX,MX,[int],[int],[int],[int],[int],[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mmin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mmin((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmin'.\n"
    "  Prototype:\n"
    "mmin(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mmin",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_mmin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_mmin__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_mmin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mmin'.\n"
    "  Possible prototypes are:\n"
    "    mmin(DM)\n"
    "    mmin(SX)\n"
    "    mmin(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mmax__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_mmax((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mmax'.\n"
    "  Prototype:\n"
    "mmax(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mmax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mmax",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_mmax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_mmax__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_mmax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mmax'.\n"
    "  Possible prototypes are:\n"
    "    mmax(DM)\n"
    "    mmax(SX)\n"
    "    mmax(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_evalf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::DM result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_evalf((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'evalf'.\n"
    "  Prototype:\n"
    "evalf(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_evalf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"evalf",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_evalf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_evalf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_evalf__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'evalf'.\n"
    "  Possible prototypes are:\n"
    "    evalf(DM)\n"
    "    evalf(SX)\n"
    "    evalf(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_cse((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse([SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_cse((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cse'.\n"
    "  Prototype:\n"
    "cse(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cse",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_cse__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      return _wrap_cse__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      return _wrap_cse__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_cse__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      return _wrap_cse__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      return _wrap_cse__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cse'.\n"
    "  Possible prototypes are:\n"
    "    cse(DM)\n"
    "    cse([DM])\n"
    "    cse([SX])\n"
    "    cse(SX)\n"
    "    cse(MX)\n"
    "    cse([MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_forward__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem > > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "SX" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_forward((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,(std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg2,(std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'forward'.\n"
    "  Prototype:\n"
    "forward([SX],[SX],[[SX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_forward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"forward",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector< casadi::Matrix<double> > > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_forward__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_forward__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector< casadi::Matrix<casadi::SXElem> > > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_forward__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_forward__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<casadi::MX> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_forward__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_forward__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'forward'.\n"
    "  Possible prototypes are:\n"
    "    forward([DM],[DM],[[DM]],dict)\n"
    "    forward([SX],[SX],[[SX]],dict)\n"
    "    forward([MX],[MX],[[MX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_reverse__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem > > > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "SX" "]" "]" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_reverse((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,(std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg2,(std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "[" "SX" "]" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'reverse'.\n"
    "  Prototype:\n"
    "reverse([SX],[SX],[[SX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reverse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"reverse",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector< casadi::Matrix<double> > > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_reverse__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_reverse__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector< casadi::Matrix<casadi::SXElem> > > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_reverse__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_reverse__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<casadi::MX> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_reverse__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_reverse__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'reverse'.\n"
    "  Possible prototypes are:\n"
    "    reverse([DM],[DM],[[DM]],dict)\n"
    "    reverse([SX],[SX],[[SX]],dict)\n"
    "    reverse([MX],[MX],[[MX]],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_substitute((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "SX" "]" "'.");
  {
    try {
      result = casadi::casadi_substitute((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,(std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg2,(std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute'.\n"
    "  Prototype:\n"
    "substitute([SX],[SX],[SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"substitute",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<double> > **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_substitute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'substitute'.\n"
    "  Possible prototypes are:\n"
    "    substitute(DM,DM,DM)\n"
    "    substitute([DM],[DM],[DM])\n"
    "    substitute(SX,SX,SX)\n"
    "    substitute([SX],[SX],[SX])\n"
    "    substitute(MX,MX,MX)\n"
    "    substitute([MX],[MX],[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_substitute_inplace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg3 = 0 ;
  bool arg4 = (bool) false ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "SX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input to type '" "[" "SX" "]" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_substitute_inplace((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,*arg2,*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'substitute_inplace'.\n"
    "  Prototype:\n"
    "substitute_inplace([SX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_substitute_inplace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"substitute_inplace",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<double> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_substitute_inplace__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_substitute_inplace__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_substitute_inplace__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_substitute_inplace__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_substitute_inplace__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< bool **>(0));
          if (_v) {
            return _wrap_substitute_inplace__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'substitute_inplace'.\n"
    "  Possible prototypes are:\n"
    "    substitute_inplace([DM],bool)\n"
    "    substitute_inplace([SX],bool)\n"
    "    substitute_inplace([MX],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_extract__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      casadi::casadi_extract((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,*arg2,*arg3,*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'extract'.\n"
    "  Prototype:\n"
    "extract([SX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_extract(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"extract",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_extract__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_extract__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_extract__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_extract__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_extract__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_extract__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'extract'.\n"
    "  Possible prototypes are:\n"
    "    extract([DM],dict)\n"
    "    extract([SX],dict)\n"
    "    extract([MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_shared__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg3 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg4 = 0 ;
  std::string const &arg5_defvalue = "v_" ;
  std::string *arg5 = (std::string *) &arg5_defvalue ;
  std::string const &arg6_defvalue = "" ;
  std::string *arg6 = (std::string *) &arg6_defvalue ;
  std::vector< casadi::Matrix< casadi::SXElem > > m1 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m3 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m4 ;
  std::string m5 ;
  std::string m6 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "SX" "]" "'.");
  if (swig_obj[1]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[2], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "str" "'.");
  }
  {
    try {
      casadi::casadi_shared((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg1,*arg2,*arg3,*arg4,(std::string const &)*arg5,(std::string const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'shared'.\n"
    "  Prototype:\n"
    "shared([SX],str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_shared(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"shared",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<double> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_shared__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_shared__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_shared__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_shared__SWIG_2(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_shared__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_shared__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_shared__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_shared__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_shared__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'shared'.\n"
    "  Possible prototypes are:\n"
    "    shared([DM],str,str)\n"
    "    shared([SX],str,str)\n"
    "    shared([MX],str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_blockcat__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > *arg1 = 0 ;
  std::vector< std::vector< casadi::Matrix< casadi::SXElem > > > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "[" "SX" "]" "]" "'.");
  {
    try {
      result = casadi::casadi_blockcat((std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'blockcat'.\n"
    "  Prototype:\n"
    "blockcat([[SX]])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_blockcat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"blockcat",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<std::vector< casadi::Matrix<double> > > **>(0));
    if (_v) {
      return _wrap_blockcat__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<std::vector< casadi::Matrix<casadi::SXElem> > > **>(0));
    if (_v) {
      return _wrap_blockcat__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<std::vector<casadi::MX> > **>(0));
    if (_v) {
      return _wrap_blockcat__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Sparsity **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Sparsity **>(0));
          if (_v) {
            return _wrap_blockcat__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<double> **>(0));
          if (_v) {
            return _wrap_blockcat__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            return _wrap_blockcat__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            return _wrap_blockcat__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'blockcat'.\n"
    "  Possible prototypes are:\n"
    "    blockcat([[DM]])\n"
    "    blockcat([[SX]])\n"
    "    blockcat([[MX]])\n"
    "    blockcat(Sparsity,Sparsity,Sparsity,Sparsity)\n"
    "    blockcat(DM,DM,DM,DM)\n"
    "    blockcat(SX,SX,SX,SX)\n"
    "    blockcat(MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_logic_all__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_all((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_all'.\n"
    "  Prototype:\n"
    "logic_all(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_any__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_any((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_any'.\n"
    "  Prototype:\n"
    "logic_any(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_adj__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_adj((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'adj'.\n"
    "  Prototype:\n"
    "adj(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_minor((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minor'.\n"
    "  Prototype:\n"
    "minor(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cofactor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_cofactor((casadi::Matrix< double > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cofactor'.\n"
    "  Prototype:\n"
    "cofactor(DM,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  
  arg2 = &m2;
  arg3 = &m3;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      casadi::casadi_qr((casadi::Matrix< double > const &)*arg1,*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr'.\n"
    "  Prototype:\n"
    "qr(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_sparse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  bool arg7 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  arg6 = &m6;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_qr_sparse((casadi::Matrix< double > const &)*arg1,*arg2,*arg3,*arg4,*arg5,*arg6,arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg6));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr_sparse'.\n"
    "  Prototype:\n"
    "qr_sparse(DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_solve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  bool arg7 = (bool) false ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "DM" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  if (swig_obj[6]) {
    if (!casadi::to_val(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_qr_solve((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(casadi::Matrix< double > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr_solve'.\n"
    "  Prototype:\n"
    "qr_solve(DM,DM,DM,DM,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  bool arg5 = (bool) true ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  std::vector< casadi_int > m4 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_ldl((casadi::Matrix< double > const &)*arg1,*arg2,*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldl'.\n"
    "  Prototype:\n"
    "ldl(DM,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldl_solve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_ldl_solve((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldl_solve'.\n"
    "  Prototype:\n"
    "ldl_solve(DM,DM,DM,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_chol((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'chol'.\n"
    "  Prototype:\n"
    "chol(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_inf_mul__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_norm_inf_mul((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_inf_mul'.\n"
    "  Prototype:\n"
    "norm_inf_mul(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsify__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  double arg2 = (double) 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  }
  {
    try {
      result = casadi::casadi_sparsify((casadi::Matrix< double > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsify'.\n"
    "  Prototype:\n"
    "sparsify(DM,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  
  arg2 = &m2;
  arg3 = &m3;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      casadi::casadi_expand((casadi::Matrix< double > const &)*arg1,*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expand'.\n"
    "  Prototype:\n"
    "expand(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_const__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_pw_const((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pw_const'.\n"
    "  Prototype:\n"
    "pw_const(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_lin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_pw_lin((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pw_lin'.\n"
    "  Prototype:\n"
    "pw_lin(DM,DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_heaviside__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_heaviside((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'heaviside'.\n"
    "  Prototype:\n"
    "heaviside(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rectangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_rectangle((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rectangle'.\n"
    "  Prototype:\n"
    "rectangle(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_triangle((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triangle'.\n"
    "  Prototype:\n"
    "triangle(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ramp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_ramp((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ramp'.\n"
    "  Prototype:\n"
    "ramp(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_quadrature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  casadi_int arg5 = (casadi_int) 5 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "DM" "'.");
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_gauss_quadrature((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(casadi::Matrix< double > const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gauss_quadrature'.\n"
    "  Prototype:\n"
    "gauss_quadrature(DM,DM,DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_quadrature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi::Matrix< double > *arg4 = 0 ;
  casadi_int arg5 ;
  casadi::Matrix< double > *arg6 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  casadi::Matrix< double > m6 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_gauss_quadrature((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,(casadi::Matrix< double > const &)*arg4,arg5,(casadi::Matrix< double > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gauss_quadrature'.\n"
    "  Prototype:\n"
    "gauss_quadrature(DM,DM,DM,DM,int,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_taylor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > const &arg3_defvalue = 0 ;
  casadi::Matrix< double > *arg3 = (casadi::Matrix< double > *) &arg3_defvalue ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_taylor((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'taylor'.\n"
    "  Prototype:\n"
    "taylor(DM,DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtaylor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_mtaylor((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtaylor'.\n"
    "  Prototype:\n"
    "mtaylor(DM,DM,DM,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtaylor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > *arg3 = 0 ;
  casadi_int arg4 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  std::vector< casadi_int > m5 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_mtaylor((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2,(casadi::Matrix< double > const &)*arg3,arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtaylor'.\n"
    "  Prototype:\n"
    "mtaylor(DM,DM,DM,int,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_poly_coeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_poly_coeff((casadi::Matrix< double > const &)*arg1,(casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'poly_coeff'.\n"
    "  Prototype:\n"
    "poly_coeff(DM,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_poly_roots__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_poly_roots((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'poly_roots'.\n"
    "  Prototype:\n"
    "poly_roots(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eig_symbolic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< double > *arg1 = 0 ;
  casadi::Matrix< double > m1 ;
  casadi::Matrix< double > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "DM" "'.");
  {
    try {
      result = casadi::casadi_eig_symbolic((casadi::Matrix< double > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eig_symbolic'.\n"
    "  Prototype:\n"
    "eig_symbolic(DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_all__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_all((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_all'.\n"
    "  Prototype:\n"
    "logic_all(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_all(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logic_all",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_logic_all__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_logic_all__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'logic_all'.\n"
    "  Possible prototypes are:\n"
    "    logic_all(DM)\n"
    "    logic_all(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_logic_any__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_any((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'logic_any'.\n"
    "  Prototype:\n"
    "logic_any(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_logic_any(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"logic_any",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_logic_any__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_logic_any__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'logic_any'.\n"
    "  Possible prototypes are:\n"
    "    logic_any(DM)\n"
    "    logic_any(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_adj__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_adj((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'adj'.\n"
    "  Prototype:\n"
    "adj(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_adj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"adj",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_adj__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_adj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'adj'.\n"
    "  Possible prototypes are:\n"
    "    adj(DM)\n"
    "    adj(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_minor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_minor((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'minor'.\n"
    "  Prototype:\n"
    "minor(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_minor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"minor",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_minor__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_minor__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'minor'.\n"
    "  Possible prototypes are:\n"
    "    minor(DM,int,int)\n"
    "    minor(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_cofactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_cofactor((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'cofactor'.\n"
    "  Prototype:\n"
    "cofactor(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cofactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"cofactor",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_cofactor__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_cofactor__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'cofactor'.\n"
    "  Possible prototypes are:\n"
    "    cofactor(DM,int,int)\n"
    "    cofactor(SX,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_qr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  
  arg2 = &m2;
  arg3 = &m3;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      casadi::casadi_qr((casadi::Matrix< casadi::SXElem > const &)*arg1,*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr'.\n"
    "  Prototype:\n"
    "qr(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"qr",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_qr__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_qr__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'qr'.\n"
    "  Possible prototypes are:\n"
    "    qr(DM)\n"
    "    qr(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_qr_sparse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  bool arg7 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  arg5 = &m5;
  arg6 = &m6;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_qr_sparse((casadi::Matrix< casadi::SXElem > const &)*arg1,*arg2,*arg3,*arg4,*arg5,*arg6,arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg5));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg6));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr_sparse'.\n"
    "  Prototype:\n"
    "qr_sparse(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_sparse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"qr_sparse",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_qr_sparse__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_qr_sparse__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_qr_sparse__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_qr_sparse__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'qr_sparse'.\n"
    "  Possible prototypes are:\n"
    "    qr_sparse(DM,bool)\n"
    "    qr_sparse(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_qr_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  bool arg7 = (bool) false ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  std::vector< casadi_int > m5 ;
  std::vector< casadi_int > m6 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "int" "]" "'.");
  if (swig_obj[6]) {
    if (!casadi::to_val(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "bool" "'.");
  }
  {
    try {
      result = casadi::casadi_qr_solve((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5,(std::vector< long long,std::allocator< long long > > const &)*arg6,arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'qr_solve'.\n"
    "  Prototype:\n"
    "qr_solve(SX,SX,SX,SX,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qr_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"qr_solve",0,7,argv))) SWIG_fail;
  --argc;
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<double> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_qr_solve__SWIG_0(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< bool **>(0));
                if (_v) {
                  return _wrap_qr_solve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<casadi_int> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_qr_solve__SWIG_1(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< bool **>(0));
                if (_v) {
                  return _wrap_qr_solve__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'qr_solve'.\n"
    "  Possible prototypes are:\n"
    "    qr_solve(DM,DM,DM,DM,[int],[int],bool)\n"
    "    qr_solve(SX,SX,SX,SX,[int],[int],bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_ldl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  bool arg5 = (bool) true ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::vector< casadi_int > m4 ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  }
  {
    try {
      casadi::casadi_ldl((casadi::Matrix< casadi::SXElem > const &)*arg1,*arg2,*arg3,*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldl'.\n"
    "  Prototype:\n"
    "ldl(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ldl",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_ldl__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_ldl__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_ldl__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< bool **>(0));
      if (_v) {
        return _wrap_ldl__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ldl'.\n"
    "  Possible prototypes are:\n"
    "    ldl(DM,bool)\n"
    "    ldl(SX,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_ldl_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::vector< casadi_int > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_ldl_solve((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ldl_solve'.\n"
    "  Prototype:\n"
    "ldl_solve(SX,SX,SX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldl_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ldl_solve",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            return _wrap_ldl_solve__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            return _wrap_ldl_solve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ldl_solve'.\n"
    "  Possible prototypes are:\n"
    "    ldl_solve(DM,DM,DM,[int])\n"
    "    ldl_solve(SX,SX,SX,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_chol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_chol((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'chol'.\n"
    "  Prototype:\n"
    "chol(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"chol",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_chol__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_chol__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'chol'.\n"
    "  Possible prototypes are:\n"
    "    chol(DM)\n"
    "    chol(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_norm_inf_mul__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_norm_inf_mul((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'norm_inf_mul'.\n"
    "  Prototype:\n"
    "norm_inf_mul(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_norm_inf_mul(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"norm_inf_mul",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_norm_inf_mul__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_norm_inf_mul__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'norm_inf_mul'.\n"
    "  Possible prototypes are:\n"
    "    norm_inf_mul(DM,DM)\n"
    "    norm_inf_mul(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_sparsify__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  double arg2 = (double) 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  }
  {
    try {
      result = casadi::casadi_sparsify((casadi::Matrix< casadi::SXElem > const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'sparsify'.\n"
    "  Prototype:\n"
    "sparsify(SX,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sparsify(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"sparsify",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_sparsify__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_sparsify__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_sparsify__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_sparsify__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'sparsify'.\n"
    "  Possible prototypes are:\n"
    "    sparsify(DM,float)\n"
    "    sparsify(SX,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_expand__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  
  arg2 = &m2;
  arg3 = &m3;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      casadi::casadi_expand((casadi::Matrix< casadi::SXElem > const &)*arg1,*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'expand'.\n"
    "  Prototype:\n"
    "expand(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"expand",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_expand__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_expand__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'expand'.\n"
    "  Possible prototypes are:\n"
    "    expand(DM)\n"
    "    expand(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_pw_const__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_pw_const((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pw_const'.\n"
    "  Prototype:\n"
    "pw_const(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_const(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"pw_const",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_pw_const__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_pw_const__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'pw_const'.\n"
    "  Possible prototypes are:\n"
    "    pw_const(DM,DM,DM)\n"
    "    pw_const(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_pw_lin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_pw_lin((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'pw_lin'.\n"
    "  Prototype:\n"
    "pw_lin(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pw_lin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"pw_lin",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_pw_lin__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          return _wrap_pw_lin__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'pw_lin'.\n"
    "  Possible prototypes are:\n"
    "    pw_lin(DM,DM,DM)\n"
    "    pw_lin(SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_heaviside__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_heaviside((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'heaviside'.\n"
    "  Prototype:\n"
    "heaviside(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_heaviside(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"heaviside",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_heaviside__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_heaviside__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'heaviside'.\n"
    "  Possible prototypes are:\n"
    "    heaviside(DM)\n"
    "    heaviside(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_rectangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_rectangle((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'rectangle'.\n"
    "  Prototype:\n"
    "rectangle(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rectangle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"rectangle",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_rectangle__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_rectangle__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'rectangle'.\n"
    "  Possible prototypes are:\n"
    "    rectangle(DM)\n"
    "    rectangle(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_triangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_triangle((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'triangle'.\n"
    "  Prototype:\n"
    "triangle(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_triangle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"triangle",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_triangle__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_triangle__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'triangle'.\n"
    "  Possible prototypes are:\n"
    "    triangle(DM)\n"
    "    triangle(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_ramp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_ramp((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'ramp'.\n"
    "  Prototype:\n"
    "ramp(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ramp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"ramp",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_ramp__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_ramp__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'ramp'.\n"
    "  Possible prototypes are:\n"
    "    ramp(DM)\n"
    "    ramp(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_gauss_quadrature__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  casadi_int arg5 = (casadi_int) 5 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  if (swig_obj[4]) {
    if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_gauss_quadrature((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4,arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gauss_quadrature'.\n"
    "  Prototype:\n"
    "gauss_quadrature(SX,SX,SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_quadrature__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg4 = 0 ;
  casadi_int arg5 ;
  casadi::Matrix< casadi::SXElem > *arg6 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > m6 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_gauss_quadrature((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4,arg5,(casadi::Matrix< casadi::SXElem > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'gauss_quadrature'.\n"
    "  Prototype:\n"
    "gauss_quadrature(SX,SX,SX,SX,int,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gauss_quadrature(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"gauss_quadrature",0,6,argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<double> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_gauss_quadrature__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_gauss_quadrature__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_gauss_quadrature__SWIG_2(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              return _wrap_gauss_quadrature__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<double> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< casadi::Matrix<double> **>(0));
              if (_v) {
                return _wrap_gauss_quadrature__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
              if (_v) {
                return _wrap_gauss_quadrature__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'gauss_quadrature'.\n"
    "  Possible prototypes are:\n"
    "    gauss_quadrature(DM,DM,DM,DM,int)\n"
    "    gauss_quadrature(SX,SX,SX,SX,int)\n"
    "    gauss_quadrature(DM,DM,DM,DM,int,DM)\n"
    "    gauss_quadrature(SX,SX,SX,SX,int,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_taylor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > const &arg3_defvalue = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = (casadi::Matrix< casadi::SXElem > *) &arg3_defvalue ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_taylor((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'taylor'.\n"
    "  Prototype:\n"
    "taylor(SX,SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_taylor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"taylor",0,4,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_taylor__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_taylor__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_taylor__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_taylor__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_taylor__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_taylor__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'taylor'.\n"
    "  Possible prototypes are:\n"
    "    taylor(DM,DM,DM,int)\n"
    "    taylor(SX,SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_mtaylor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi_int arg4 = (casadi_int) 1 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::casadi_mtaylor((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtaylor'.\n"
    "  Prototype:\n"
    "mtaylor(SX,SX,SX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtaylor__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg3 = 0 ;
  casadi_int arg4 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  std::vector< casadi_int > m5 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "int" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  {
    try {
      result = casadi::casadi_mtaylor((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,arg4,(std::vector< long long,std::allocator< long long > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'mtaylor'.\n"
    "  Prototype:\n"
    "mtaylor(SX,SX,SX,int,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtaylor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"mtaylor",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_mtaylor__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_mtaylor__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_mtaylor__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            return _wrap_mtaylor__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              return _wrap_mtaylor__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi_int **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<casadi_int> **>(0));
            if (_v) {
              return _wrap_mtaylor__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'mtaylor'.\n"
    "  Possible prototypes are:\n"
    "    mtaylor(DM,DM,DM,int)\n"
    "    mtaylor(SX,SX,SX,int)\n"
    "    mtaylor(DM,DM,DM,int,[int])\n"
    "    mtaylor(SX,SX,SX,int,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_poly_coeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_poly_coeff((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'poly_coeff'.\n"
    "  Prototype:\n"
    "poly_coeff(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_poly_coeff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"poly_coeff",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_poly_coeff__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_poly_coeff__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'poly_coeff'.\n"
    "  Possible prototypes are:\n"
    "    poly_coeff(DM,DM)\n"
    "    poly_coeff(SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_poly_roots__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_poly_roots((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'poly_roots'.\n"
    "  Prototype:\n"
    "poly_roots(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_poly_roots(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"poly_roots",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_poly_roots__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_poly_roots__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'poly_roots'.\n"
    "  Possible prototypes are:\n"
    "    poly_roots(DM)\n"
    "    poly_roots(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_eig_symbolic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Matrix< casadi::SXElem > *arg1 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  {
    try {
      result = casadi::casadi_eig_symbolic((casadi::Matrix< casadi::SXElem > const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'eig_symbolic'.\n"
    "  Prototype:\n"
    "eig_symbolic(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eig_symbolic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"eig_symbolic",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<double> **>(0));
    if (_v) {
      return _wrap_eig_symbolic__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      return _wrap_eig_symbolic__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'eig_symbolic'.\n"
    "  Possible prototypes are:\n"
    "    eig_symbolic(DM)\n"
    "    eig_symbolic(SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_find((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'find'.\n"
    "  Prototype:\n"
    "find(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_low(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"low",2,3,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_low((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'low'.\n"
    "  Prototype:\n"
    "low(MX,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inv_node(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_inv_node((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'inv_node'.\n"
    "  Prototype:\n"
    "inv_node(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_matrix_expand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg2_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg2_defvalue ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  }
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_matrix_expand((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'matrix_expand'.\n"
    "  Prototype:\n"
    "matrix_expand([MX],[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_matrix_expand__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg2_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg2_defvalue ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::MX m1 ;
  std::vector< casadi::MX > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::MX result;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  }
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_matrix_expand((casadi::MX const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'matrix_expand'.\n"
    "  Prototype:\n"
    "matrix_expand(MX,[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_matrix_expand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"matrix_expand",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_matrix_expand__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_matrix_expand__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_matrix_expand__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_matrix_expand__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_matrix_expand__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_matrix_expand__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'matrix_expand'.\n"
    "  Possible prototypes are:\n"
    "    matrix_expand(MX,[MX],dict)\n"
    "    matrix_expand([MX],[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_graph_substitute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  casadi::MX m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_graph_substitute((casadi::MX const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'graph_substitute'.\n"
    "  Prototype:\n"
    "graph_substitute(MX,[MX],[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_graph_substitute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX > m1 ;
  std::vector< casadi::MX > m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "MX" "]" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  {
    try {
      result = casadi::casadi_graph_substitute((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg1,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'graph_substitute'.\n"
    "  Prototype:\n"
    "graph_substitute([MX],[MX],[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_graph_substitute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"graph_substitute",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_graph_substitute__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::vector<casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_graph_substitute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'graph_substitute'.\n"
    "  Possible prototypes are:\n"
    "    graph_substitute(MX,[MX],[MX])\n"
    "    graph_substitute([MX],[MX],[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_bspline__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::DM *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi_int arg5 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  casadi::MX m1 ;
  casadi::Matrix< double > m2 ;
  std::vector< std::vector< double > > m3 ;
  std::vector< casadi_int > m4 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::MX result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "float" "]" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_bspline((casadi::MX const &)*arg1,(casadi::Matrix< double > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bspline'.\n"
    "  Prototype:\n"
    "bspline(MX,DM,[[float]],[int],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bspline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg4 = 0 ;
  casadi_int arg5 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  std::vector< std::vector< double > > m3 ;
  std::vector< casadi_int > m4 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::MX result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "[" "float" "]" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "int" "]" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "int" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_bspline((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(std::vector< long long,std::allocator< long long > > const &)*arg4,arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'bspline'.\n"
    "  Prototype:\n"
    "bspline(MX,MX,[[float]],[int],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bspline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"bspline",0,6,argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<double> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_bspline__SWIG_0(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_bspline__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::vector<double> > **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi_int> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi_int **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_bspline__SWIG_1(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_bspline__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'bspline'.\n"
    "  Possible prototypes are:\n"
    "    bspline(MX,DM,[[float]],[int],int,dict)\n"
    "    bspline(MX,MX,[[float]],[int],int,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_convexify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  casadi::MX m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"convexify",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::casadi_convexify((casadi::MX const &)*arg1,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'convexify'.\n"
    "  Prototype:\n"
    "convexify(MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stop_diff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi_int arg2 ;
  casadi::MX m1 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_stop_diff((casadi::MX const &)*arg1,arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'stop_diff'.\n"
    "  Prototype:\n"
    "stop_diff(MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stop_diff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_int arg3 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      result = casadi::casadi_stop_diff((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'stop_diff'.\n"
    "  Prototype:\n"
    "stop_diff(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stop_diff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"stop_diff",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_stop_diff__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_stop_diff__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'stop_diff'.\n"
    "  Possible prototypes are:\n"
    "    stop_diff(MX,int)\n"
    "    stop_diff(MX,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_no_hess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_no_hess((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'no_hess'.\n"
    "  Prototype:\n"
    "no_hess(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_no_grad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX m1 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  {
    try {
      result = casadi::casadi_no_grad((casadi::MX const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'no_grad'.\n"
    "  Prototype:\n"
    "no_grad(MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Importer::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'Importer_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Importer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::Importer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::Importer *)new casadi::Importer();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Importer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_Importer'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Importer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Importer *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::Importer *)new casadi::Importer((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Importer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Importer'.\n"
    "  Prototype:\n"
    "Importer(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_test_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SharedObjectInternal *arg1 = (casadi::SharedObjectInternal *) 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_casadi__SharedObjectInternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_test_cast" "', argument " "1"" of type '" "casadi::SharedObjectInternal const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SharedObjectInternal * >(argp1);
  {
    try {
      result = (bool)casadi::Importer::test_cast((casadi::SharedObjectInternal const *)arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_test_cast'.\n"
    "  Prototype:\n"
    "test_cast(casadi::SharedObjectInternal const *)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_has_plugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (bool)casadi::Importer::has_plugin((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_has_plugin'.\n"
    "  Prototype:\n"
    "has_plugin(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_load_plugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::Importer::load_plugin((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_load_plugin'.\n"
    "  Prototype:\n"
    "load_plugin(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_doc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::Importer::doc((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_doc'.\n"
    "  Prototype:\n"
    "doc(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_plugin_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 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_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_plugin_name" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  {
    try {
      result = ((casadi::Importer const *)arg1)->plugin_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_plugin_name'.\n"
    "  Prototype:\n"
    "plugin_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_has_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_has_function",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_has_function" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::Importer const *)arg1)->has_function((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_has_function'.\n"
    "  Prototype:\n"
    "has_function(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_has_meta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_has_meta",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_has_meta" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (bool)((casadi::Importer const *)arg1)->has_meta((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_has_meta'.\n"
    "  Prototype:\n"
    "has_meta(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_get_meta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_get_meta",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_get_meta" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::Importer const *)arg1)->get_meta((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_get_meta'.\n"
    "  Prototype:\n"
    "get_meta(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_inlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_inlined",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_inlined" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::Importer const *)arg1)->inlined((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_inlined'.\n"
    "  Prototype:\n"
    "inlined(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_body",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_body" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::Importer const *)arg1)->body((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_body'.\n"
    "  Prototype:\n"
    "body(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_library(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 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_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_library" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  {
    try {
      result = ((casadi::Importer const *)arg1)->library();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_library'.\n"
    "  Prototype:\n"
    "library(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 0 ;
  casadi::SerializingStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Importer_serialize",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Importer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_serialize" "', argument " "1"" of type '" "casadi::Importer const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializingStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Importer_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Importer_serialize" "', argument " "2"" of type '" "casadi::SerializingStream &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializingStream * >(argp2);
  {
    try {
      ((casadi::Importer const *)arg1)->serialize(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_serialize'.\n"
    "  Prototype:\n"
    "serialize(self,casadi::SerializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Importer_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializingStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Importer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DeserializingStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Importer_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Importer_deserialize" "', argument " "1"" of type '" "casadi::DeserializingStream &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializingStream * >(argp1);
  {
    try {
      result = casadi::Importer::deserialize(*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::Importer(static_cast< const casadi::Importer& >(result))), SWIGTYPE_p_casadi__Importer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Importer_deserialize'.\n"
    "  Prototype:\n"
    "deserialize(casadi::DeserializingStream &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Importer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Importer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__Importer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Importer" "', argument " "1"" of type '" "casadi::Importer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Importer" "', argument " "1"" of type '" "casadi::Importer const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  {
    result = (casadi::Importer *)new casadi::Importer((casadi::Importer const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Importer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Importer'.\n"
    "  Prototype:\n"
    "Importer(Importer)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Importer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Importer",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Importer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__Importer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Importer__SWIG_2(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_Importer__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_new_Importer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Importer'.\n"
    "  Possible prototypes are:\n"
    "    Importer()\n"
    "    Importer(Importer)\n"
    "    Importer(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Importer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Importer *arg1 = (casadi::Importer *) 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_casadi__Importer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Importer" "', argument " "1"" of type '" "casadi::Importer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Importer * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Importer'.\n"
    "  Prototype:\n"
    "Importer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_Callback_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::Callback::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'Callback_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  casadi::Callback *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (casadi::Callback *)new SwigDirector_Callback(arg1); 
      } else {
        result = (casadi::Callback *)new casadi::Callback(); 
      }
      
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Callback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Callback'.\n"
    "  Prototype:\n"
    "Callback(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Callback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  casadi::Callback *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  casadi::Callback *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__Callback,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Callback" "', argument " "2"" of type '" "casadi::Callback const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Callback" "', argument " "2"" of type '" "casadi::Callback const &""'"); 
  }
  arg2 = reinterpret_cast< casadi::Callback * >(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (casadi::Callback *)new SwigDirector_Callback(arg1,(casadi::Callback const &)*arg2); 
      } else {
        result = (casadi::Callback *)new casadi::Callback((casadi::Callback const &)*arg2); 
      }
      
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Callback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Callback'.\n"
    "  Prototype:\n"
    "Callback(self,Callback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Callback",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_Callback__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_casadi__Callback, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Callback__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Callback'.\n"
    "  Possible prototypes are:\n"
    "    Callback(self)\n"
    "    Callback(self,Callback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 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_casadi__Callback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Callback" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Callback'.\n"
    "  Prototype:\n"
    "Callback(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_construct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_construct",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_construct" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      (arg1)->construct((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_construct'.\n"
    "  Prototype:\n"
    "construct(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_init" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->casadi::Callback::init();
        } else {
          (arg1)->init();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_init'.\n"
    "  Prototype:\n"
    "init(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_finalize" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->casadi::Callback::finalize();
        } else {
          (arg1)->finalize();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_finalize'.\n"
    "  Prototype:\n"
    "finalize(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_eval",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_eval" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((casadi::Callback const *)arg1)->casadi::Callback::eval((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
        } else {
          result = ((casadi::Callback const *)arg1)->eval((std::vector< casadi::DM,std::allocator< casadi::DM > > const &)*arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_eval'.\n"
    "  Prototype:\n"
    "eval(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_eval_buffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  double **arg2 = (double **) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg3 = 0 ;
  double **arg4 = (double **) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< casadi_int > m3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  std::vector< casadi_int > m5 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_eval_buffer",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_eval_buffer" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Callback_eval_buffer" "', argument " "2"" of type '" "double const **""'"); 
  }
  arg2 = reinterpret_cast< double ** >(argp2);
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "int" "]" "'.");
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Callback_eval_buffer" "', argument " "4"" of type '" "double **""'"); 
  }
  arg4 = reinterpret_cast< double ** >(argp4);
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "int" "]" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((casadi::Callback const *)arg1)->casadi::Callback::eval_buffer((double const **)arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5);
        } else {
          result = (int)((casadi::Callback const *)arg1)->eval_buffer((double const **)arg2,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg3,arg4,(std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg5);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_eval_buffer'.\n"
    "  Prototype:\n"
    "eval_buffer(self,double const **,[int],double **,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_has_eval_buffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_has_eval_buffer" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::has_eval_buffer();
        } else {
          result = (bool)((casadi::Callback const *)arg1)->has_eval_buffer();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_has_eval_buffer'.\n"
    "  Prototype:\n"
    "has_eval_buffer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_n_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_n_in" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (casadi_int)(arg1)->casadi::Callback::get_n_in();
        } else {
          result = (casadi_int)(arg1)->get_n_in();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_n_in'.\n"
    "  Prototype:\n"
    "get_n_in(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_n_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_n_out" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (casadi_int)(arg1)->casadi::Callback::get_n_out();
        } else {
          result = (casadi_int)(arg1)->get_n_out();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_n_out'.\n"
    "  Prototype:\n"
    "get_n_out(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_sparsity_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_sparsity_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_sparsity_in" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->casadi::Callback::get_sparsity_in(arg2);
        } else {
          result = (arg1)->get_sparsity_in(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_sparsity_in'.\n"
    "  Prototype:\n"
    "get_sparsity_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_sparsity_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_sparsity_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_sparsity_out" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->casadi::Callback::get_sparsity_out(arg2);
        } else {
          result = (arg1)->get_sparsity_out(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_sparsity_out'.\n"
    "  Prototype:\n"
    "get_sparsity_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_name_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_name_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_name_in" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->casadi::Callback::get_name_in(arg2);
        } else {
          result = (arg1)->get_name_in(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_name_in'.\n"
    "  Prototype:\n"
    "get_name_in(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_name_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_name_out",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_name_out" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->casadi::Callback::get_name_out(arg2);
        } else {
          result = (arg1)->get_name_out(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_name_out'.\n"
    "  Prototype:\n"
    "get_name_out(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_uses_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_uses_output" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::uses_output();
        } else {
          result = (bool)((casadi::Callback const *)arg1)->uses_output();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_uses_output'.\n"
    "  Prototype:\n"
    "uses_output(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_has_jacobian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_has_jacobian" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::has_jacobian();
        } else {
          result = (bool)((casadi::Callback const *)arg1)->has_jacobian();
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_has_jacobian'.\n"
    "  Prototype:\n"
    "has_jacobian(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_jacobian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_jacobian",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_jacobian" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((casadi::Callback const *)arg1)->casadi::Callback::get_jacobian((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
        } else {
          result = ((casadi::Callback const *)arg1)->get_jacobian((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_jacobian'.\n"
    "  Prototype:\n"
    "get_jacobian(self,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_has_forward(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_has_forward",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_has_forward" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::has_forward(arg2);
        } else {
          result = (bool)((casadi::Callback const *)arg1)->has_forward(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_has_forward'.\n"
    "  Prototype:\n"
    "has_forward(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_forward(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  std::string *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m3 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_forward",6,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_forward" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((casadi::Callback const *)arg1)->casadi::Callback::get_forward(arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
        } else {
          result = ((casadi::Callback const *)arg1)->get_forward(arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_forward'.\n"
    "  Prototype:\n"
    "get_forward(self,int,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_has_reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_has_reverse",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_has_reverse" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::has_reverse(arg2);
        } else {
          result = (bool)((casadi::Callback const *)arg1)->has_reverse(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_has_reverse'.\n"
    "  Prototype:\n"
    "has_reverse(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  std::string *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m3 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_reverse",6,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_reverse" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((casadi::Callback const *)arg1)->casadi::Callback::get_reverse(arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
        } else {
          result = ((casadi::Callback const *)arg1)->get_reverse(arg2,(std::string const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_reverse'.\n"
    "  Prototype:\n"
    "get_reverse(self,int,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_has_jac_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_has_jac_sparsity",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_has_jac_sparsity" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((casadi::Callback const *)arg1)->casadi::Callback::has_jac_sparsity(arg2,arg3);
        } else {
          result = (bool)((casadi::Callback const *)arg1)->has_jac_sparsity(arg2,arg3);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_has_jac_sparsity'.\n"
    "  Prototype:\n"
    "has_jac_sparsity(self,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_get_jac_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 0 ;
  casadi_int arg2 ;
  casadi_int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  bool upcall = false;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"Callback_get_jac_sparsity",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_get_jac_sparsity" "', argument " "1"" of type '" "casadi::Callback const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((casadi::Callback const *)arg1)->casadi::Callback::get_jac_sparsity(arg2,arg3,arg4);
        } else {
          result = ((casadi::Callback const *)arg1)->get_jac_sparsity(arg2,arg3,arg4);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Callback_get_jac_sparsity'.\n"
    "  Prototype:\n"
    "get_jac_sparsity(self,int,int,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Callback *arg1 = (casadi::Callback *) 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_casadi__Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Callback" "', argument " "1"" of type '" "casadi::Callback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Callback * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_GlobalOptions_setSimplificationOnTheFly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "bool" "'.");
  {
    try {
      casadi::GlobalOptions::setSimplificationOnTheFly(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GlobalOptions_setSimplificationOnTheFly'.\n"
    "  Prototype:\n"
    "setSimplificationOnTheFly(bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_getSimplificationOnTheFly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalOptions_getSimplificationOnTheFly",0,0,0)) SWIG_fail;
  {
    try {
      result = (bool)casadi::GlobalOptions::getSimplificationOnTheFly();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'GlobalOptions_getSimplificationOnTheFly'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_setHierarchicalSparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "bool" "'.");
  {
    try {
      casadi::GlobalOptions::setHierarchicalSparsity(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GlobalOptions_setHierarchicalSparsity'.\n"
    "  Prototype:\n"
    "setHierarchicalSparsity(bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_getHierarchicalSparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalOptions_getHierarchicalSparsity",0,0,0)) SWIG_fail;
  {
    try {
      result = (bool)casadi::GlobalOptions::getHierarchicalSparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'GlobalOptions_getHierarchicalSparsity'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_setCasadiPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::GlobalOptions::setCasadiPath((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GlobalOptions_setCasadiPath'.\n"
    "  Prototype:\n"
    "setCasadiPath(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_getCasadiPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalOptions_getCasadiPath",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::GlobalOptions::getCasadiPath();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'GlobalOptions_getCasadiPath'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_setCasadiIncludePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::GlobalOptions::setCasadiIncludePath((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GlobalOptions_setCasadiIncludePath'.\n"
    "  Prototype:\n"
    "setCasadiIncludePath(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_getCasadiIncludePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalOptions_getCasadiIncludePath",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::GlobalOptions::getCasadiIncludePath();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'GlobalOptions_getCasadiIncludePath'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_setMaxNumDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  {
    try {
      casadi::GlobalOptions::setMaxNumDir(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'GlobalOptions_setMaxNumDir'.\n"
    "  Prototype:\n"
    "setMaxNumDir(int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalOptions_getMaxNumDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalOptions_getMaxNumDir",0,0,0)) SWIG_fail;
  {
    try {
      result = (casadi_int)casadi::GlobalOptions::getMaxNumDir();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'GlobalOptions_getMaxNumDir'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GlobalOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GlobalOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::GlobalOptions *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__GlobalOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GlobalOptions" "', argument " "1"" of type '" "casadi::GlobalOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalOptions" "', argument " "1"" of type '" "casadi::GlobalOptions const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::GlobalOptions * >(argp1);
  {
    result = (casadi::GlobalOptions *)new casadi::GlobalOptions((casadi::GlobalOptions const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__GlobalOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_GlobalOptions'.\n"
    "  Prototype:\n"
    "GlobalOptions(GlobalOptions)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GlobalOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::GlobalOptions *arg1 = (casadi::GlobalOptions *) 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_casadi__GlobalOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GlobalOptions" "', argument " "1"" of type '" "casadi::GlobalOptions *""'"); 
  }
  arg1 = reinterpret_cast< casadi::GlobalOptions * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_GlobalOptions'.\n"
    "  Prototype:\n"
    "GlobalOptions(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_CasadiMeta_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_version",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::version();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_version'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_git_revision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_git_revision",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::git_revision();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_git_revision'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_git_describe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_git_describe",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::git_describe();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_git_describe'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_feature_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_feature_list",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::feature_list();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_feature_list'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_build_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_build_type",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::build_type();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_build_type'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_compiler_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_compiler_id",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::compiler_id();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_compiler_id'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_compiler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_compiler",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::compiler();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_compiler'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_compiler_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_compiler_flags",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::compiler_flags();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_compiler_flags'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_modules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_modules",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::modules();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_modules'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_plugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_plugins",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::plugins();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_plugins'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_CasadiMeta_install_prefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CasadiMeta_install_prefix",0,0,0)) SWIG_fail;
  {
    try {
      result = (char *)casadi::CasadiMeta::install_prefix();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'CasadiMeta_install_prefix'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CasadiMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CasadiMeta *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::CasadiMeta *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__CasadiMeta,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CasadiMeta" "', argument " "1"" of type '" "casadi::CasadiMeta const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CasadiMeta" "', argument " "1"" of type '" "casadi::CasadiMeta const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::CasadiMeta * >(argp1);
  {
    result = (casadi::CasadiMeta *)new casadi::CasadiMeta((casadi::CasadiMeta const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__CasadiMeta, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_CasadiMeta'.\n"
    "  Prototype:\n"
    "CasadiMeta(CasadiMeta)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CasadiMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::CasadiMeta *arg1 = (casadi::CasadiMeta *) 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_casadi__CasadiMeta, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CasadiMeta" "', argument " "1"" of type '" "casadi::CasadiMeta *""'"); 
  }
  arg1 = reinterpret_cast< casadi::CasadiMeta * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_CasadiMeta'.\n"
    "  Prototype:\n"
    "CasadiMeta(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_collocation_points(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi_int arg1 ;
  std::string const &arg2_defvalue = "radau" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"collocation_points",1,2,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "int" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = casadi::collocation_points(arg1,(std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'collocation_points'.\n"
    "  Prototype:\n"
    "collocation_points(int,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_collocation_interpolators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::vector< double > m1 ;
  std::vector< std::vector< double > > m2 ;
  std::vector< double > m3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  {
    try {
      casadi::collocation_interpolators((std::vector< double,std::allocator< double > > const &)*arg1,*arg2,*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'collocation_interpolators'.\n"
    "  Prototype:\n"
    "collocation_interpolators([float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_collocation_coeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > *arg1 = 0 ;
  casadi::DM *arg2 = 0 ;
  casadi::DM *arg3 = 0 ;
  casadi::DM *arg4 = 0 ;
  std::vector< double > m1 ;
  casadi::Matrix< double > m2 ;
  casadi::Matrix< double > m3 ;
  casadi::Matrix< double > m4 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &m2;
  arg3 = &m3;
  arg4 = &m4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "[" "float" "]" "'.");
  {
    try {
      casadi::collocation_coeff((std::vector< double,std::allocator< double > > const &)*arg1,*arg2,*arg3,*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'collocation_coeff'.\n"
    "  Prototype:\n"
    "collocation_coeff([float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simpleRK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function arg1 ;
  casadi_int arg2 = (casadi_int) 10 ;
  casadi_int arg3 = (casadi_int) 4 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"simpleRK",1,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = casadi::simpleRK(arg1,arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'simpleRK'.\n"
    "  Prototype:\n"
    "simpleRK(Function,int,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simpleIRK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function arg1 ;
  casadi_int arg2 = (casadi_int) 10 ;
  casadi_int arg3 = (casadi_int) 4 ;
  std::string const &arg4_defvalue = "radau" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  std::string const &arg5_defvalue = "newton" ;
  std::string *arg5 = (std::string *) &arg5_defvalue ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  std::string m4 ;
  std::string m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  PyObject *swig_obj[6] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"simpleIRK",1,6,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "str" "'.");
  }
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::simpleIRK(arg1,arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'simpleIRK'.\n"
    "  Prototype:\n"
    "simpleIRK(Function,int,int,str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_simpleIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Function arg1 ;
  std::string const &arg2_defvalue = "cvodes" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"simpleIntegrator",1,3,swig_obj)) SWIG_fail;
  if (!casadi::to_val(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "Function" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::simpleIntegrator(arg1,(std::string const &)*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'simpleIntegrator'.\n"
    "  Prototype:\n"
    "simpleIntegrator(Function,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_reduce_index__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MXDict *arg1 = 0 ;
  casadi::Dict *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = {
    
  } ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::map< std::string,casadi::MX > m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::MXDict result;
  
  arg2 = &m2;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "MX" "'.");
  if (swig_obj[1]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dae_reduce_index((std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg1,*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "MX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_reduce_index'.\n"
    "  Prototype:\n"
    "dae_reduce_index(dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_reduce_index__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SXDict *arg1 = 0 ;
  casadi::Dict *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = {
    
  } ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::SXDict result;
  
  arg2 = &m2;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "SX" "'.");
  if (swig_obj[1]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dae_reduce_index((std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg1,*arg2,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "SX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg2));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_reduce_index'.\n"
    "  Prototype:\n"
    "dae_reduce_index(dict:SX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_reduce_index(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dae_reduce_index",0,2,argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_dae_reduce_index__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_dae_reduce_index__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::MX> **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_dae_reduce_index__SWIG_0(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_dae_reduce_index__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dae_reduce_index'.\n"
    "  Possible prototypes are:\n"
    "    dae_reduce_index(dict:SX,dict)\n"
    "    dae_reduce_index(dict:MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dae_map_semi_expl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MXDict *arg1 = 0 ;
  casadi::MXDict *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Function *arg4 = 0 ;
  std::map< std::string,casadi::MX > m1 ;
  std::map< std::string,casadi::MX > m2 ;
  casadi::Function m3 ;
  casadi::Function m4 ;
  casadi::MXDict result;
  
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  {
    try {
      result = casadi::dae_map_semi_expl((std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg1,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg2,*arg3,*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "MX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_map_semi_expl'.\n"
    "  Prototype:\n"
    "dae_map_semi_expl(dict:MX,dict:MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_map_semi_expl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SXDict *arg1 = 0 ;
  casadi::SXDict *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Function *arg4 = 0 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m1 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  casadi::Function m3 ;
  casadi::Function m4 ;
  casadi::SXDict result;
  
  arg3 = &m3;
  arg4 = &m4;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  {
    try {
      result = casadi::dae_map_semi_expl((std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg1,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg2,*arg3,*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "SX" "'.");
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg3));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg4));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_map_semi_expl'.\n"
    "  Prototype:\n"
    "dae_map_semi_expl(dict:SX,dict:SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_map_semi_expl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dae_map_semi_expl",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_dae_map_semi_expl__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        return _wrap_dae_map_semi_expl__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dae_map_semi_expl'.\n"
    "  Possible prototypes are:\n"
    "    dae_map_semi_expl(dict:SX,dict:SX)\n"
    "    dae_map_semi_expl(dict:MX,dict:MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_dae_init_gen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MXDict *arg1 = 0 ;
  casadi::MXDict *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::DMDict const &arg4_defvalue = casadi::DMDict() ;
  casadi::DMDict *arg4 = (casadi::DMDict *) &arg4_defvalue ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::map< std::string,casadi::MX > m1 ;
  std::map< std::string,casadi::MX > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::Matrix< double > > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" ":" "DM" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dae_init_gen((std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg1,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::Matrix< double >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< double > > > > const &)*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_init_gen'.\n"
    "  Prototype:\n"
    "dae_init_gen(dict:MX,dict:MX,str,dict:DM,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_init_gen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SXDict *arg1 = 0 ;
  casadi::SXDict *arg2 = 0 ;
  std::string *arg3 = 0 ;
  casadi::DMDict const &arg4_defvalue = casadi::DMDict() ;
  casadi::DMDict *arg4 = (casadi::DMDict *) &arg4_defvalue ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m1 ;
  std::map< std::string,casadi::Matrix< casadi::SXElem > > m2 ;
  std::string m3 ;
  std::map< std::string,casadi::Matrix< double > > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" ":" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" ":" "DM" "'.");
  }
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::dae_init_gen((std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg1,(std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > const &)*arg2,(std::string const &)*arg3,(std::map< std::string,casadi::Matrix< double >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< double > > > > const &)*arg4,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'dae_init_gen'.\n"
    "  Prototype:\n"
    "dae_init_gen(dict:SX,dict:SX,str,dict:DM,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dae_init_gen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"dae_init_gen",0,5,argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dae_init_gen__SWIG_1(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_dae_init_gen__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_dae_init_gen__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::map<std::string,casadi::MX> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          if (argc <= 3) {
            return _wrap_dae_init_gen__SWIG_0(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_dae_init_gen__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_dae_init_gen__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'dae_init_gen'.\n"
    "  Possible prototypes are:\n"
    "    dae_init_gen(dict:SX,dict:SX,str,dict:DM,dict)\n"
    "    dae_init_gen(dict:MX,dict:MX,str,dict:DM,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_detect_simple_bounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SX *arg1 = 0 ;
  casadi::SX *arg2 = 0 ;
  casadi::SX *arg3 = 0 ;
  casadi::SX *arg4 = 0 ;
  casadi::SX *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  casadi::SX *arg7 = 0 ;
  casadi::SX *arg8 = 0 ;
  casadi::Function *arg9 = 0 ;
  casadi::Function *arg10 = 0 ;
  casadi::Matrix< casadi::SXElem > m1 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  casadi::Matrix< casadi::SXElem > m3 ;
  casadi::Matrix< casadi::SXElem > m4 ;
  casadi::Matrix< casadi::SXElem > m5 ;
  std::vector< casadi_int > m6 ;
  casadi::Matrix< casadi::SXElem > m7 ;
  casadi::Matrix< casadi::SXElem > m8 ;
  casadi::Function m9 ;
  casadi::Function m10 ;
  
  arg6 = &m6;
  arg7 = &m7;
  arg8 = &m8;
  arg9 = &m9;
  arg10 = &m10;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "SX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "SX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "SX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "SX" "'.");
  {
    try {
      casadi::detect_simple_bounds((casadi::Matrix< casadi::SXElem > const &)*arg1,(casadi::Matrix< casadi::SXElem > const &)*arg2,(casadi::Matrix< casadi::SXElem > const &)*arg3,(casadi::Matrix< casadi::SXElem > const &)*arg4,(casadi::Matrix< casadi::SXElem > const &)*arg5,*arg6,*arg7,*arg8,*arg9,*arg10);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg6));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg7));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg8));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg9));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg10));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'detect_simple_bounds'.\n"
    "  Prototype:\n"
    "detect_simple_bounds(SX,SX,SX,SX,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_detect_simple_bounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  casadi::MX *arg5 = 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg6 = 0 ;
  casadi::MX *arg7 = 0 ;
  casadi::MX *arg8 = 0 ;
  casadi::Function *arg9 = 0 ;
  casadi::Function *arg10 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  casadi::MX m5 ;
  std::vector< casadi_int > m6 ;
  casadi::MX m7 ;
  casadi::MX m8 ;
  casadi::Function m9 ;
  casadi::Function m10 ;
  
  arg6 = &m6;
  arg7 = &m7;
  arg8 = &m8;
  arg9 = &m9;
  arg10 = &m10;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "MX" "'.");
  {
    try {
      casadi::detect_simple_bounds((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(casadi::MX const &)*arg4,(casadi::MX const &)*arg5,*arg6,*arg7,*arg8,*arg9,*arg10);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg6));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg7));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg8));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg9));
  resultobj = SWIG_Python_AppendOutput(resultobj, casadi::from_ptr(arg10));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'detect_simple_bounds'.\n"
    "  Prototype:\n"
    "detect_simple_bounds(MX,MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_detect_simple_bounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"detect_simple_bounds",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
            if (_v) {
              return _wrap_detect_simple_bounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< casadi::MX **>(0));
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::MX **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< casadi::MX **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< casadi::MX **>(0));
            if (_v) {
              return _wrap_detect_simple_bounds__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'detect_simple_bounds'.\n"
    "  Possible prototypes are:\n"
    "    detect_simple_bounds(SX,SX,SX,SX,SX)\n"
    "    detect_simple_bounds(MX,MX,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_external_transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  casadi::Function *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  std::string m1 ;
  std::string m2 ;
  casadi::Function m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"external_transform",3,4,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Function" "'.");
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = casadi::external_transform((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Function const &)*arg3,(std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'external_transform'.\n"
    "  Prototype:\n"
    "external_transform(str,str,Function,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_x_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) & ((arg1)->x);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_x_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_x_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_f_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (casadi::MX *) & ((arg1)->f);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_f_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_f_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_g_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_g_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) & ((arg1)->g);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_g_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_g_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_x_lb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_x_lb_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->x_lb);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_x_lb_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_x_lb_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_x_ub_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_x_ub_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->x_ub);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_x_ub_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_x_ub_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_g_lb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_g_lb_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->g_lb);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_g_lb_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_g_lb_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_g_ub_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_g_ub_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->g_ub);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_g_ub_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_g_ub_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_x_init_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_x_init_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->x_init);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_x_init_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_x_init_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_lambda_init_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_lambda_init_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) & ((arg1)->lambda_init);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_lambda_init_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_lambda_init_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_discrete_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_discrete_get" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  result = (std::vector< bool,std::allocator< bool > > *) & ((arg1)->discrete);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "bool" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_discrete_get'.\n"
    "  Prototype:\n"
    "NlpBuilder_discrete_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_import_nl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"NlpBuilder_import_nl",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_import_nl" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      (arg1)->import_nl((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_import_nl'.\n"
    "  Prototype:\n"
    "import_nl(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 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_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_type_name" "', argument " "1"" of type '" "casadi::NlpBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  {
    try {
      result = ((casadi::NlpBuilder const *)arg1)->type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_type_name'.\n"
    "  Prototype:\n"
    "type_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"NlpBuilder_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_disp" "', argument " "1"" of type '" "casadi::NlpBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::NlpBuilder const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_NlpBuilder_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"NlpBuilder_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__NlpBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NlpBuilder_str" "', argument " "1"" of type '" "casadi::NlpBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::NlpBuilder const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'NlpBuilder_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NlpBuilder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::NlpBuilder *)new casadi::NlpBuilder();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__NlpBuilder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_NlpBuilder'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NlpBuilder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::NlpBuilder *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__NlpBuilder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NlpBuilder" "', argument " "1"" of type '" "casadi::NlpBuilder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NlpBuilder" "', argument " "1"" of type '" "casadi::NlpBuilder const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  {
    result = (casadi::NlpBuilder *)new casadi::NlpBuilder((casadi::NlpBuilder const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__NlpBuilder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_NlpBuilder'.\n"
    "  Prototype:\n"
    "NlpBuilder(NlpBuilder)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NlpBuilder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_NlpBuilder",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NlpBuilder__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__NlpBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NlpBuilder__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_NlpBuilder'.\n"
    "  Possible prototypes are:\n"
    "    NlpBuilder()\n"
    "    NlpBuilder(NlpBuilder)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NlpBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::NlpBuilder *arg1 = (casadi::NlpBuilder *) 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_casadi__NlpBuilder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NlpBuilder" "', argument " "1"" of type '" "casadi::NlpBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::NlpBuilder * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_NlpBuilder'.\n"
    "  Prototype:\n"
    "NlpBuilder(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_DaeBuilder_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_type_name" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_type_name'.\n"
    "  Prototype:\n"
    "type_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DaeBuilder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::DaeBuilder *)new casadi::DaeBuilder();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__DaeBuilder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_DaeBuilder'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DaeBuilder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string const &arg2_defvalue = "" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  std::string m1 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::DaeBuilder *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::DaeBuilder *)new casadi::DaeBuilder((std::string const &)*arg1,(std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__DaeBuilder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DaeBuilder'.\n"
    "  Prototype:\n"
    "DaeBuilder(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_name" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::string *) &((casadi::DaeBuilder const *)arg1)->name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_name'.\n"
    "  Prototype:\n"
    "name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_t" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi::MX *) &((casadi::DaeBuilder const *)arg1)->t();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_t'.\n"
    "  Prototype:\n"
    "t(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_x" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->x();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_x'.\n"
    "  Prototype:\n"
    "x(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_ode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_ode" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->ode();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_ode'.\n"
    "  Prototype:\n"
    "ode(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_z" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->z();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_z'.\n"
    "  Prototype:\n"
    "z(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_alg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_alg" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->alg();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_alg'.\n"
    "  Prototype:\n"
    "alg(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_q" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->q();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_q'.\n"
    "  Prototype:\n"
    "q(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_quad" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->quad();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_quad'.\n"
    "  Prototype:\n"
    "quad(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_y" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->y();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_y'.\n"
    "  Prototype:\n"
    "y(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_ydef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_ydef" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->ydef();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_ydef'.\n"
    "  Prototype:\n"
    "ydef(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_u" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->u();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_u'.\n"
    "  Prototype:\n"
    "u(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_p" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->p();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_p'.\n"
    "  Prototype:\n"
    "p(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_c" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->c();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_c'.\n"
    "  Prototype:\n"
    "c(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_cdef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_cdef" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->cdef();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_cdef'.\n"
    "  Prototype:\n"
    "cdef(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_d" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->d();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_d'.\n"
    "  Prototype:\n"
    "d(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_ddef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_ddef" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->ddef();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_ddef'.\n"
    "  Prototype:\n"
    "ddef(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_w" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->w();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_w'.\n"
    "  Prototype:\n"
    "w(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_wdef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_wdef" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->wdef();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_wdef'.\n"
    "  Prototype:\n"
    "wdef(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_aux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_aux" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->aux();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_aux'.\n"
    "  Prototype:\n"
    "aux(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_init_lhs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_init_lhs" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->init_lhs();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_init_lhs'.\n"
    "  Prototype:\n"
    "init_lhs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_init_rhs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_init_rhs" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->init_rhs();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_init_rhs'.\n"
    "  Prototype:\n"
    "init_rhs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_when_cond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_when_cond" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->when_cond();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_when_cond'.\n"
    "  Prototype:\n"
    "when_cond(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_when_lhs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_when_lhs" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->when_lhs();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_when_lhs'.\n"
    "  Prototype:\n"
    "when_lhs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_when_rhs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_when_rhs" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &((casadi::DaeBuilder const *)arg1)->when_rhs();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_when_rhs'.\n"
    "  Prototype:\n"
    "when_rhs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_outputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_outputs" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->outputs();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_outputs'.\n"
    "  Prototype:\n"
    "outputs(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_derivatives(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_derivatives" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->derivatives();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_derivatives'.\n"
    "  Prototype:\n"
    "derivatives(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_initial_unknowns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_initial_unknowns" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->initial_unknowns();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_initial_unknowns'.\n"
    "  Prototype:\n"
    "initial_unknowns(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_has_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_has_t" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (bool)((casadi::DaeBuilder const *)arg1)->has_t();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_has_t'.\n"
    "  Prototype:\n"
    "has_t(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nx" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nx'.\n"
    "  Prototype:\n"
    "nx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nz" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nz();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nz'.\n"
    "  Prototype:\n"
    "nz(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nq" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nq();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nq'.\n"
    "  Prototype:\n"
    "nq(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_ny(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_ny" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->ny();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_ny'.\n"
    "  Prototype:\n"
    "ny(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nu" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nu();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nu'.\n"
    "  Prototype:\n"
    "nu(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_np(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_np" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->np();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_np'.\n"
    "  Prototype:\n"
    "np(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nc" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nc();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nc'.\n"
    "  Prototype:\n"
    "nc(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nd" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nd();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nd'.\n"
    "  Prototype:\n"
    "nd(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nw" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->nw();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nw'.\n"
    "  Prototype:\n"
    "nw(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = "t" ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_t",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_t" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_t((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_t'.\n"
    "  Prototype:\n"
    "add_t(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_p",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_p" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_p((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_p'.\n"
    "  Prototype:\n"
    "add_p(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_u",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_u" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_u((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_u'.\n"
    "  Prototype:\n"
    "add_u(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_x",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_x" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_x((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_x'.\n"
    "  Prototype:\n"
    "add_x(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_z",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_z" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_z((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_z'.\n"
    "  Prototype:\n"
    "add_z(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_q",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_q" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->add_q((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_q'.\n"
    "  Prototype:\n"
    "add_q(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_c",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_c" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = (arg1)->add_c((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_c'.\n"
    "  Prototype:\n"
    "add_c(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_d",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_d" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = (arg1)->add_d((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_d'.\n"
    "  Prototype:\n"
    "add_d(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_w",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_w" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = (arg1)->add_w((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_w'.\n"
    "  Prototype:\n"
    "add_w(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_y",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_y" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = (arg1)->add_y((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_y'.\n"
    "  Prototype:\n"
    "add_y(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_ode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_ode",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_ode" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      (arg1)->set_ode((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_ode'.\n"
    "  Prototype:\n"
    "set_ode(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_alg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_alg",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_alg" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      (arg1)->set_alg((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_alg'.\n"
    "  Prototype:\n"
    "set_alg(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_aux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string const &arg2_defvalue = std::string() ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  casadi_int arg3 = (casadi_int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_aux",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_aux" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (arg1)->add_aux((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_aux'.\n"
    "  Prototype:\n"
    "add_aux(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_init",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_init" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      (arg1)->add_init((casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_init'.\n"
    "  Prototype:\n"
    "add_init(self,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_when(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  casadi::MX m4 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_when",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_when" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "MX" "'.");
  {
    try {
      (arg1)->add_when((casadi::MX const &)*arg2,(casadi::MX const &)*arg3,(casadi::MX const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_when'.\n"
    "  Prototype:\n"
    "add_when(self,MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_sanity_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_sanity_check" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      ((casadi::DaeBuilder const *)arg1)->sanity_check();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_sanity_check'.\n"
    "  Prototype:\n"
    "sanity_check(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_clear_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_clear_all",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_clear_all" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->clear_all((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_clear_all'.\n"
    "  Prototype:\n"
    "clear_all(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_all",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_all" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set_all((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_all'.\n"
    "  Prototype:\n"
    "set_all(self,str,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_t",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_t" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_t((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_t'.\n"
    "  Prototype:\n"
    "register_t(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_p",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_p" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_p((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_p'.\n"
    "  Prototype:\n"
    "register_p(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_u",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_u" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_u((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_u'.\n"
    "  Prototype:\n"
    "register_u(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_x",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_x" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_x((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_x'.\n"
    "  Prototype:\n"
    "register_x(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_z",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_z" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_z((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_z'.\n"
    "  Prototype:\n"
    "register_z(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_q",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_q" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_q((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_q'.\n"
    "  Prototype:\n"
    "register_q(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_c",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_c" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_c((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_c'.\n"
    "  Prototype:\n"
    "register_c(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_d",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_d" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_d((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_d'.\n"
    "  Prototype:\n"
    "register_d(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_w",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_w" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_w((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_w'.\n"
    "  Prototype:\n"
    "register_w(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_register_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_register_y",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_register_y" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->register_y((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_register_y'.\n"
    "  Prototype:\n"
    "register_y(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_u",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_u" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set_u((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_u'.\n"
    "  Prototype:\n"
    "set_u(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_x",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_x" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set_x((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_x'.\n"
    "  Prototype:\n"
    "set_x(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > const &arg3_defvalue = std::vector< std::string >() ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = (std::vector< std::string,std::allocator< std::string > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_z",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_z" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  }
  {
    try {
      (arg1)->set_z((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_z'.\n"
    "  Prototype:\n"
    "set_z(self,[str],[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_q",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_q" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set_q((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_q'.\n"
    "  Prototype:\n"
    "set_q(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_y",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_y" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set_y((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_y'.\n"
    "  Prototype:\n"
    "set_y(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_clear_in(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_clear_in",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_clear_in" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->clear_in((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_clear_in'.\n"
    "  Prototype:\n"
    "clear_in(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_eliminate_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_eliminate_w" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->eliminate_w();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_eliminate_w'.\n"
    "  Prototype:\n"
    "eliminate_w(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_lift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  bool arg2 = (bool) true ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_lift",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_lift" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->lift(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_lift'.\n"
    "  Prototype:\n"
    "lift(self,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_eliminate_quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_eliminate_quad" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->eliminate_quad();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_eliminate_quad'.\n"
    "  Prototype:\n"
    "eliminate_quad(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_sort_d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_sort_d" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->sort_d();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_sort_d'.\n"
    "  Prototype:\n"
    "sort_d(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_sort_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_sort_w" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->sort_w();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_sort_w'.\n"
    "  Prototype:\n"
    "sort_w(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_sort_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_sort_z",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_sort_z" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->sort_z((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_sort_z'.\n"
    "  Prototype:\n"
    "sort_z(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_prune(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  bool arg2 = (bool) true ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_prune",1,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_prune" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->prune(arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_prune'.\n"
    "  Prototype:\n"
    "prune(self,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_tear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_tear" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->tear();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_tear'.\n"
    "  Prototype:\n"
    "tear(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_fun__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_fun" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->add_fun((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_fun'.\n"
    "  Prototype:\n"
    "add_fun(self,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_fun__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::Function *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function m2 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_fun" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Function" "'.");
  {
    try {
      result = (arg1)->add_fun((casadi::Function const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_fun'.\n"
    "  Prototype:\n"
    "add_fun(self,Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_fun__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Importer *arg3 = 0 ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::map< std::string,casadi::GenericType > m4 ;
  casadi::Function result;
  
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_fun" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_casadi__Importer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DaeBuilder_add_fun" "', argument " "3"" of type '" "casadi::Importer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DaeBuilder_add_fun" "', argument " "3"" of type '" "casadi::Importer const &""'"); 
  }
  arg3 = reinterpret_cast< casadi::Importer * >(argp3);
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->add_fun((std::string const &)*arg2,(casadi::Importer const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_fun'.\n"
    "  Prototype:\n"
    "add_fun(self,str,Importer,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_fun(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_add_fun",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Function **>(0));
      if (_v) {
        return _wrap_DaeBuilder_add_fun__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_casadi__Importer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_DaeBuilder_add_fun__SWIG_2(self, argc, argv);
          }
          _v = casadi::to_ptr(argv[3], static_cast< std::map<std::string,casadi::GenericType> **>(0));
          if (_v) {
            return _wrap_DaeBuilder_add_fun__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_DaeBuilder_add_fun__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_DaeBuilder_add_fun__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_add_fun'.\n"
    "  Possible prototypes are:\n"
    "    add_fun(self,Function)\n"
    "    add_fun(self,str,Importer,dict)\n"
    "    add_fun(self,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_has_fun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_has_fun",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_has_fun" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::DaeBuilder const *)arg1)->has_fun((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_has_fun'.\n"
    "  Prototype:\n"
    "has_fun(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_fun__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_fun" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->fun((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_fun'.\n"
    "  Prototype:\n"
    "fun(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_fun__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_fun" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->fun();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Function" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_fun'.\n"
    "  Prototype:\n"
    "fun(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_fun(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_fun",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DaeBuilder_fun__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_fun__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_fun'.\n"
    "  Possible prototypes are:\n"
    "    fun(self)\n"
    "    fun(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_gather_fun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi_int arg2 = (casadi_int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_gather_fun",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_gather_fun" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  {
    try {
      (arg1)->gather_fun(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_gather_fun'.\n"
    "  Prototype:\n"
    "gather_fun(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_parse_fmi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_parse_fmi",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_parse_fmi" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->parse_fmi((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_parse_fmi'.\n"
    "  Prototype:\n"
    "parse_fmi(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_provides_directional_derivative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_provides_directional_derivative" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = (bool)((casadi::DaeBuilder const *)arg1)->provides_directional_derivative();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_provides_directional_derivative'.\n"
    "  Prototype:\n"
    "provides_directional_derivative(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_load_fmi_description(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_load_fmi_description",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_load_fmi_description" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->load_fmi_description((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_load_fmi_description'.\n"
    "  Prototype:\n"
    "load_fmi_description(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_export_fmu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_export_fmu",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_export_fmu" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->export_fmu((casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_export_fmu'.\n"
    "  Prototype:\n"
    "export_fmu(self,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_lc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_add_lc",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_lc" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->add_lc((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_lc'.\n"
    "  Prototype:\n"
    "add_lc(self,str,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  bool arg5 ;
  bool arg6 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_create" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (!casadi::to_val(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "bool" "'.");
  if (swig_obj[5]) {
    if (!casadi::to_val(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->create((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,arg5,arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_create'.\n"
    "  Prototype:\n"
    "create(self,str,[str],[str],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_create" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->create((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_create'.\n"
    "  Prototype:\n"
    "create(self,str,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  casadi::Function result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_create" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->create((std::string const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_create'.\n"
    "  Prototype:\n"
    "create(self,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_create",0,6,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_DaeBuilder_create__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_create__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_DaeBuilder_create__SWIG_1(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_DaeBuilder_create__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< bool **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_DaeBuilder_create__SWIG_0(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< bool **>(0));
              if (_v) {
                return _wrap_DaeBuilder_create__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_create'.\n"
    "  Possible prototypes are:\n"
    "    create(self,str,dict)\n"
    "    create(self,str,[str],[str],dict)\n"
    "    create(self,str,[str],[str],bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_dependent_fun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 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 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< std::string > m4 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_dependent_fun",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_dependent_fun" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->dependent_fun((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_dependent_fun'.\n"
    "  Prototype:\n"
    "dependent_fun(self,str,[str],[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_var(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_var",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_var" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->var((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_var'.\n"
    "  Prototype:\n"
    "var(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder___call__",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder___call__" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->operator ()((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder___call__'.\n"
    "  Prototype:\n"
    "__call__(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_der__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_der" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->der((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_der'.\n"
    "  Prototype:\n"
    "der(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_beq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_beq",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_beq" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->beq((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_beq'.\n"
    "  Prototype:\n"
    "beq(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_beq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_beq",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_beq" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      (arg1)->set_beq((std::string const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_beq'.\n"
    "  Prototype:\n"
    "set_beq(self,str,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_value_reference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_value_reference",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_value_reference" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->value_reference((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_value_reference'.\n"
    "  Prototype:\n"
    "value_reference(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_value_reference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_value_reference",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_value_reference" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  {
    try {
      (arg1)->set_value_reference((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_value_reference'.\n"
    "  Prototype:\n"
    "set_value_reference(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_description(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_description",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_description" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->description((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_description'.\n"
    "  Prototype:\n"
    "description(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_description(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_description",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_description" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_description((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_description'.\n"
    "  Prototype:\n"
    "set_description(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_type",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_type" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->type((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_type'.\n"
    "  Prototype:\n"
    "type(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_type",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_type" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_type((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_type'.\n"
    "  Prototype:\n"
    "set_type(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_causality(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_causality",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_causality" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->causality((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_causality'.\n"
    "  Prototype:\n"
    "causality(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_causality(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_causality",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_causality" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_causality((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_causality'.\n"
    "  Prototype:\n"
    "set_causality(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_variability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_variability",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_variability" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->variability((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_variability'.\n"
    "  Prototype:\n"
    "variability(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_variability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_variability",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_variability" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_variability((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_variability'.\n"
    "  Prototype:\n"
    "set_variability(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_initial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_initial",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_initial" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->initial((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_initial'.\n"
    "  Prototype:\n"
    "initial(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_initial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_initial",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_initial" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_initial((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_initial'.\n"
    "  Prototype:\n"
    "set_initial(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_unit",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_unit" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->unit((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_unit'.\n"
    "  Prototype:\n"
    "unit(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_unit",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_unit" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_unit((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_unit'.\n"
    "  Prototype:\n"
    "set_unit(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_display_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_display_unit",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_display_unit" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->display_unit((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_display_unit'.\n"
    "  Prototype:\n"
    "display_unit(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_display_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_set_display_unit",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_display_unit" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set_display_unit((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_display_unit'.\n"
    "  Prototype:\n"
    "set_display_unit(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_numel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  casadi_int result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_numel",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_numel" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (casadi_int)((casadi::DaeBuilder const *)arg1)->numel((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_numel'.\n"
    "  Prototype:\n"
    "numel(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_dimension",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_dimension" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->dimension((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_dimension'.\n"
    "  Prototype:\n"
    "dimension(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_der__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_der" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->der((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_der'.\n"
    "  Prototype:\n"
    "der(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_der(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_der",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_der__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_der__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_der'.\n"
    "  Possible prototypes are:\n"
    "    der(self,[str])\n"
    "    der(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_attribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  double result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_attribute" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      result = (double)((casadi::DaeBuilder const *)arg1)->attribute((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_attribute'.\n"
    "  Prototype:\n"
    "attribute(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_attribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_attribute" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "float" "'.");
  {
    try {
      (arg1)->set_attribute((std::string const &)*arg2,(std::string const &)*arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_attribute'.\n"
    "  Prototype:\n"
    "set_attribute(self,str,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_min__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_min" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (double)((casadi::DaeBuilder const *)arg1)->min((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_min'.\n"
    "  Prototype:\n"
    "min(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_min__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_min" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "float" "'.");
  {
    try {
      (arg1)->set_min((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_min'.\n"
    "  Prototype:\n"
    "set_min(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_max__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_max" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (double)((casadi::DaeBuilder const *)arg1)->max((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_max'.\n"
    "  Prototype:\n"
    "max(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_max__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_max" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "float" "'.");
  {
    try {
      (arg1)->set_max((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_max'.\n"
    "  Prototype:\n"
    "set_max(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nominal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nominal" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (double)((casadi::DaeBuilder const *)arg1)->nominal((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nominal'.\n"
    "  Prototype:\n"
    "nominal(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_nominal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_nominal" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "float" "'.");
  {
    try {
      (arg1)->set_nominal((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_nominal'.\n"
    "  Prototype:\n"
    "set_nominal(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_start__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_start" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (double)((casadi::DaeBuilder const *)arg1)->start((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_start'.\n"
    "  Prototype:\n"
    "start(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_start__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_start" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "float" "'.");
  {
    try {
      (arg1)->set_start((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_start'.\n"
    "  Prototype:\n"
    "set_start(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_reset" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_reset'.\n"
    "  Prototype:\n"
    "reset(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "float" "'.");
  {
    try {
      (arg1)->set((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set'.\n"
    "  Prototype:\n"
    "set(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::string m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "str" "'.");
  {
    try {
      (arg1)->set((std::string const &)*arg2,(std::string const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set'.\n"
    "  Prototype:\n"
    "set(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::GenericType result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_get" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->get((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "GenericType" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_get'.\n"
    "  Prototype:\n"
    "get(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_attribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_attribute" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->attribute((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_attribute'.\n"
    "  Prototype:\n"
    "attribute(self,str,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_attribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_attribute",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_attribute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_DaeBuilder_attribute__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_attribute'.\n"
    "  Possible prototypes are:\n"
    "    attribute(self,str,[str])\n"
    "    attribute(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_attribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< std::string > m3 ;
  std::vector< double > m4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_attribute" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set_attribute((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_attribute'.\n"
    "  Prototype:\n"
    "set_attribute(self,str,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_attribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set_attribute",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<double> **>(0));
          if (_v) {
            return _wrap_DaeBuilder_set_attribute__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< double **>(0));
          if (_v) {
            return _wrap_DaeBuilder_set_attribute__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set_attribute'.\n"
    "  Possible prototypes are:\n"
    "    set_attribute(self,str,[str],[float])\n"
    "    set_attribute(self,str,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_min__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_min" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->min((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_min'.\n"
    "  Prototype:\n"
    "min(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_min(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_min",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_min__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_min__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_min'.\n"
    "  Possible prototypes are:\n"
    "    min(self,[str])\n"
    "    min(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_min__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_min" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set_min((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_min'.\n"
    "  Prototype:\n"
    "set_min(self,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_min(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set_min",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_min__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< double **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_min__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set_min'.\n"
    "  Possible prototypes are:\n"
    "    set_min(self,[str],[float])\n"
    "    set_min(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_max__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_max" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->max((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_max'.\n"
    "  Prototype:\n"
    "max(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_max(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_max",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_max__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_max__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_max'.\n"
    "  Possible prototypes are:\n"
    "    max(self,[str])\n"
    "    max(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_max__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_max" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set_max((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_max'.\n"
    "  Prototype:\n"
    "set_max(self,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_max(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set_max",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_max__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< double **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_max__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set_max'.\n"
    "  Possible prototypes are:\n"
    "    set_max(self,[str],[float])\n"
    "    set_max(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nominal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_nominal" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->nominal((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_nominal'.\n"
    "  Prototype:\n"
    "nominal(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_nominal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_nominal",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_nominal__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_nominal__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_nominal'.\n"
    "  Possible prototypes are:\n"
    "    nominal(self,[str])\n"
    "    nominal(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_nominal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_nominal" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set_nominal((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_nominal'.\n"
    "  Prototype:\n"
    "set_nominal(self,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_nominal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set_nominal",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_nominal__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< double **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_nominal__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set_nominal'.\n"
    "  Possible prototypes are:\n"
    "    set_nominal(self,[str],[float])\n"
    "    set_nominal(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_start__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_start" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->start((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_start'.\n"
    "  Prototype:\n"
    "start(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_start(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_start",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_start__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_start__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_start'.\n"
    "  Possible prototypes are:\n"
    "    start(self,[str])\n"
    "    start(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_start__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set_start" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set_start((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set_start'.\n"
    "  Prototype:\n"
    "set_start(self,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set_start(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set_start",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_start__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< double **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set_start__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set_start'.\n"
    "  Possible prototypes are:\n"
    "    set_start(self,[str],[float])\n"
    "    set_start(self,str,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->set((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set'.\n"
    "  Prototype:\n"
    "set(self,[str],[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_set" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->set((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_set'.\n"
    "  Prototype:\n"
    "set(self,[str],[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_set",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<double> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<std::string> **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< double **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::string **>(0));
        if (_v) {
          return _wrap_DaeBuilder_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_set'.\n"
    "  Possible prototypes are:\n"
    "    set(self,[str],[float])\n"
    "    set(self,[str],[str])\n"
    "    set(self,str,float)\n"
    "    set(self,str,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< casadi::GenericType,std::allocator< casadi::GenericType > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_get" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->get((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "GenericType" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_get'.\n"
    "  Prototype:\n"
    "get(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_get",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_DaeBuilder_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_DaeBuilder_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_get'.\n"
    "  Possible prototypes are:\n"
    "    get(self,[str])\n"
    "    get(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::MX result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (arg1)->add_variable((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable'.\n"
    "  Prototype:\n"
    "add_variable(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Sparsity m3 ;
  casadi::MX result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  {
    try {
      result = (arg1)->add_variable((std::string const &)*arg2,(casadi::Sparsity const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable'.\n"
    "  Prototype:\n"
    "add_variable(self,str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      (arg1)->add_variable((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable'.\n"
    "  Prototype:\n"
    "add_variable(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_add_variable",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_DaeBuilder_add_variable__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_DaeBuilder_add_variable__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_DaeBuilder_add_variable__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_DaeBuilder_add_variable__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_add_variable'.\n"
    "  Possible prototypes are:\n"
    "    add_variable(self,MX)\n"
    "    add_variable(self,str,int)\n"
    "    add_variable(self,str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable_new__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi_int arg3 = (casadi_int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  size_t result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable_new" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = (arg1)->add_variable_new((std::string const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable_new'.\n"
    "  Prototype:\n"
    "add_variable_new(self,str,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable_new__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Sparsity *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  casadi::Sparsity m3 ;
  size_t result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable_new" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "Sparsity" "'.");
  {
    try {
      result = (arg1)->add_variable_new((std::string const &)*arg2,(casadi::Sparsity const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable_new'.\n"
    "  Prototype:\n"
    "add_variable_new(self,str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable_new__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  size_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_add_variable_new" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (arg1)->add_variable_new((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_add_variable_new'.\n"
    "  Prototype:\n"
    "add_variable_new(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_add_variable_new(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DaeBuilder_add_variable_new",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_DaeBuilder_add_variable_new__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_DaeBuilder_add_variable_new__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< casadi_int **>(0));
        if (_v) {
          return _wrap_DaeBuilder_add_variable_new__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Sparsity **>(0));
        if (_v) {
          return _wrap_DaeBuilder_add_variable_new__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'DaeBuilder_add_variable_new'.\n"
    "  Possible prototypes are:\n"
    "    add_variable_new(self,MX)\n"
    "    add_variable_new(self,str,int)\n"
    "    add_variable_new(self,str,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_has_variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_has_variable",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_has_variable" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      result = (bool)((casadi::DaeBuilder const *)arg1)->has_variable((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_has_variable'.\n"
    "  Prototype:\n"
    "has_variable(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_all_variables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_all_variables" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->all_variables();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_all_variables'.\n"
    "  Prototype:\n"
    "all_variables(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_oracle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[4] ;
  casadi::Function result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_oracle",1,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_oracle" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  if (swig_obj[3]) {
    if (!casadi::to_val(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->oracle(arg2,arg3,arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_oracle'.\n"
    "  Prototype:\n"
    "oracle(self,bool,bool,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DaeBuilder_jac_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  std::vector< std::string > m3 ;
  PyObject *swig_obj[3] ;
  casadi::Sparsity result;
  
  if (!SWIG_Python_UnpackTuple(args,"DaeBuilder_jac_sparsity",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DaeBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DaeBuilder_jac_sparsity" "', argument " "1"" of type '" "casadi::DaeBuilder const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "str" "]" "'.");
  {
    try {
      result = ((casadi::DaeBuilder const *)arg1)->jac_sparsity((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DaeBuilder_jac_sparsity'.\n"
    "  Prototype:\n"
    "jac_sparsity(self,[str],[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DaeBuilder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::DaeBuilder *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__DaeBuilder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DaeBuilder" "', argument " "1"" of type '" "casadi::DaeBuilder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DaeBuilder" "', argument " "1"" of type '" "casadi::DaeBuilder const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    result = (casadi::DaeBuilder *)new casadi::DaeBuilder((casadi::DaeBuilder const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__DaeBuilder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_DaeBuilder'.\n"
    "  Prototype:\n"
    "DaeBuilder(DaeBuilder)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DaeBuilder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DaeBuilder",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DaeBuilder__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__DaeBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DaeBuilder__SWIG_2(self, argc, argv);
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_DaeBuilder__SWIG_1(self, argc, argv);
      }
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_DaeBuilder__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_new_DaeBuilder__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_DaeBuilder'.\n"
    "  Possible prototypes are:\n"
    "    DaeBuilder()\n"
    "    DaeBuilder(DaeBuilder)\n"
    "    DaeBuilder(str,str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DaeBuilder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DaeBuilder *arg1 = (casadi::DaeBuilder *) 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_casadi__DaeBuilder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DaeBuilder" "', argument " "1"" of type '" "casadi::DaeBuilder *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DaeBuilder * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_DaeBuilder'.\n"
    "  Prototype:\n"
    "DaeBuilder(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_XmlFile_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"XmlFile_type_name",0,0,0)) SWIG_fail;
  {
    try {
      result = casadi::XmlFile::type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'XmlFile_type_name'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::XmlFile *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::XmlFile *)new casadi::XmlFile();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__XmlFile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_XmlFile'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  casadi::XmlFile *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (casadi::XmlFile *)new casadi::XmlFile((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__XmlFile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_XmlFile'.\n"
    "  Prototype:\n"
    "XmlFile(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XmlFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::XmlFile *arg1 = (casadi::XmlFile *) 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_casadi__XmlFile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlFile" "', argument " "1"" of type '" "casadi::XmlFile *""'"); 
  }
  arg1 = reinterpret_cast< casadi::XmlFile * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_XmlFile'.\n"
    "  Prototype:\n"
    "XmlFile(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_XmlFile_load_plugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      casadi::XmlFile::load_plugin((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'XmlFile_load_plugin'.\n"
    "  Prototype:\n"
    "load_plugin(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_XmlFile_doc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = casadi::XmlFile::doc((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'XmlFile_doc'.\n"
    "  Prototype:\n"
    "doc(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::XmlFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::XmlFile *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__XmlFile,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XmlFile" "', argument " "1"" of type '" "casadi::XmlFile const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XmlFile" "', argument " "1"" of type '" "casadi::XmlFile const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::XmlFile * >(argp1);
  {
    result = (casadi::XmlFile *)new casadi::XmlFile((casadi::XmlFile const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__XmlFile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_XmlFile'.\n"
    "  Prototype:\n"
    "XmlFile(XmlFile)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_XmlFile",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XmlFile__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__XmlFile, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XmlFile__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_new_XmlFile__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_XmlFile'.\n"
    "  Possible prototypes are:\n"
    "    XmlFile()\n"
    "    XmlFile(XmlFile)\n"
    "    XmlFile(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


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

SWIGINTERN PyObject *_wrap_delete_SerializerBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 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_casadi__SerializerBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SerializerBase" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_SerializerBase'.\n"
    "  Prototype:\n"
    "SerializerBase(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::Sparsity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Sparsity m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Sparsity" "'.");
  {
    try {
      (arg1)->pack((casadi::Sparsity const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,Sparsity)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      (arg1)->pack((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::Matrix< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  {
    try {
      (arg1)->pack((casadi::Matrix< double > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::Matrix< casadi::SXElem > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  {
    try {
      (arg1)->pack((casadi::Matrix< casadi::SXElem > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,SX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::Linsol *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_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__Linsol,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SerializerBase_pack" "', argument " "2"" of type '" "casadi::Linsol const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SerializerBase_pack" "', argument " "2"" of type '" "casadi::Linsol const &""'"); 
  }
  arg2 = reinterpret_cast< casadi::Linsol * >(argp2);
  {
    try {
      (arg1)->pack((casadi::Linsol const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,Linsol)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::Function *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Function m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "Function" "'.");
  {
    try {
      (arg1)->pack((casadi::Function const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,Function)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::GenericType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::GenericType m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "GenericType" "'.");
  {
    try {
      (arg1)->pack((casadi::GenericType const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,GenericType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi_int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi_int m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      (arg1)->pack((casadi_int const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  {
    try {
      (arg1)->pack((double const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->pack((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Sparsity > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "Sparsity" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[Sparsity])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< double > > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "DM" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[DM])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Matrix< casadi::SXElem > > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "SX" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[SX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_14(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > *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_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SerializerBase_pack" "', argument " "2"" of type '" "std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SerializerBase_pack" "', argument " "2"" of type '" "std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > * >(argp2);
  {
    try {
      (arg1)->pack((std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const &)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_15(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::Function > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "Function" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::Function,std::allocator< casadi::Function > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[Function])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_16(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi::GenericType,std::allocator< casadi::GenericType > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::GenericType > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "GenericType" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi::GenericType,std::allocator< casadi::GenericType > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[GenericType])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_17(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< casadi_int,std::allocator< casadi_int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi_int > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "int" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< casadi_int,std::allocator< casadi_int > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[int])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_18(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "float" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< double,std::allocator< double > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[float])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack__SWIG_19(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_pack" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "str" "]" "'.");
  {
    try {
      (arg1)->pack((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_pack'.\n"
    "  Prototype:\n"
    "pack(self,[str])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_pack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"SerializerBase_pack",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_casadi__Linsol, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_14(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi_int **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< double **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Sparsity> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_10(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Sparsity **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<double> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_18(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi_int> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_17(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<std::string> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_19(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_12(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector< casadi::Matrix<casadi::SXElem> > **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_13(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::Function> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_15(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Function **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::GenericType> **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_16(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__SerializerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::GenericType **>(0));
      if (_v) {
        return _wrap_SerializerBase_pack__SWIG_6(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'SerializerBase_pack'.\n"
    "  Possible prototypes are:\n"
    "    pack(self,Linsol)\n"
    "    pack(self,std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const &)\n"
    "    pack(self,int)\n"
    "    pack(self,float)\n"
    "    pack(self,[Sparsity])\n"
    "    pack(self,Sparsity)\n"
    "    pack(self,[float])\n"
    "    pack(self,[int])\n"
    "    pack(self,[str])\n"
    "    pack(self,DM)\n"
    "    pack(self,[DM])\n"
    "    pack(self,SX)\n"
    "    pack(self,[SX])\n"
    "    pack(self,MX)\n"
    "    pack(self,[MX])\n"
    "    pack(self,str)\n"
    "    pack(self,[Function])\n"
    "    pack(self,Function)\n"
    "    pack(self,[GenericType])\n"
    "    pack(self,GenericType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_SerializerBase_type_to_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SerializerBase::SerializationType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string 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 '" "SerializerBase_type_to_string" "', argument " "1"" of type '" "casadi::SerializerBase::SerializationType""'");
  } 
  arg1 = static_cast< casadi::SerializerBase::SerializationType >(val1);
  {
    try {
      result = casadi::SerializerBase::type_to_string(arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_type_to_string'.\n"
    "  Prototype:\n"
    "type_to_string(casadi::SerializerBase::SerializationType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 0 ;
  casadi::DeserializerBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SerializerBase_connect",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_connect" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__DeserializerBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SerializerBase_connect" "', argument " "2"" of type '" "casadi::DeserializerBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SerializerBase_connect" "', argument " "2"" of type '" "casadi::DeserializerBase &""'"); 
  }
  arg2 = reinterpret_cast< casadi::DeserializerBase * >(argp2);
  {
    try {
      (arg1)->connect(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_connect'.\n"
    "  Prototype:\n"
    "connect(self,DeserializerBase)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SerializerBase_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::SerializerBase *arg1 = (casadi::SerializerBase *) 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_casadi__SerializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SerializerBase_reset" "', argument " "1"" of type '" "casadi::SerializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::SerializerBase * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'SerializerBase_reset'.\n"
    "  Prototype:\n"
    "reset(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_delete_DeserializerBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 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_casadi__DeserializerBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeserializerBase" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_DeserializerBase'.\n"
    "  Prototype:\n"
    "DeserializerBase(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase__pop_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::SerializerBase::SerializationType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase__pop_type" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (casadi::SerializerBase::SerializationType)(arg1)->pop_type();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase__pop_type'.\n"
    "  Prototype:\n"
    "_pop_type(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_sparsity" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_sparsity'.\n"
    "  Prototype:\n"
    "blind_unpack_sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_mx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_mx" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_mx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_mx'.\n"
    "  Prototype:\n"
    "blind_unpack_mx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_dm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_dm" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_dm();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_dm'.\n"
    "  Prototype:\n"
    "blind_unpack_dm(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_sx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_sx" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_sx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_sx'.\n"
    "  Prototype:\n"
    "blind_unpack_sx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Linsol result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_linsol" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_linsol();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::Linsol(static_cast< const casadi::Linsol& >(result))), SWIGTYPE_p_casadi__Linsol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_linsol'.\n"
    "  Prototype:\n"
    "blind_unpack_linsol(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_function" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_function();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_function'.\n"
    "  Prototype:\n"
    "blind_unpack_function(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_generictype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::GenericType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_generictype" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_generictype();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "GenericType" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_generictype'.\n"
    "  Prototype:\n"
    "blind_unpack_generictype(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_int" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (casadi_int)(arg1)->blind_unpack_int();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_int'.\n"
    "  Prototype:\n"
    "blind_unpack_int(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_double" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (double)(arg1)->blind_unpack_double();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_double'.\n"
    "  Prototype:\n"
    "blind_unpack_double(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 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_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_string" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_string();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_string'.\n"
    "  Prototype:\n"
    "blind_unpack_string(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_sparsity_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_sparsity_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_sparsity_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_sparsity_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_sparsity_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_mx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_mx_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_mx_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_mx_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_mx_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_dm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_dm_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_dm_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_dm_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_dm_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_sx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_sx_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_sx_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_sx_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_sx_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_linsol_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_linsol_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_linsol_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >(static_cast< const std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >& >(result))), SWIGTYPE_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_linsol_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_linsol_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_function_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_function_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_function_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Function" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_function_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_function_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_generictype_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::GenericType,std::allocator< casadi::GenericType > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_generictype_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_generictype_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "GenericType" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_generictype_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_generictype_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_int_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_int_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_int_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_int_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_int_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_double_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_double_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_double_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_double_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_double_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_blind_unpack_string_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_blind_unpack_string_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->blind_unpack_string_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_blind_unpack_string_vector'.\n"
    "  Prototype:\n"
    "blind_unpack_string_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_sparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Sparsity result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_sparsity" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_sparsity();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Sparsity" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_sparsity'.\n"
    "  Prototype:\n"
    "unpack_sparsity(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_mx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_mx" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_mx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_mx'.\n"
    "  Prototype:\n"
    "unpack_mx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_dm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< double > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_dm" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_dm();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_dm'.\n"
    "  Prototype:\n"
    "unpack_dm(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_sx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Matrix< casadi::SXElem > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_sx" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_sx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "SX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_sx'.\n"
    "  Prototype:\n"
    "unpack_sx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_linsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Linsol result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_linsol" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_linsol();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::Linsol(static_cast< const casadi::Linsol& >(result))), SWIGTYPE_p_casadi__Linsol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_linsol'.\n"
    "  Prototype:\n"
    "unpack_linsol(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_function(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_function" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_function();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_function'.\n"
    "  Prototype:\n"
    "unpack_function(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_generictype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::GenericType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_generictype" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_generictype();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "GenericType" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_generictype'.\n"
    "  Prototype:\n"
    "unpack_generictype(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_int" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (casadi_int)(arg1)->unpack_int();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_int'.\n"
    "  Prototype:\n"
    "unpack_int(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_double" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (double)(arg1)->unpack_double();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "float" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_double'.\n"
    "  Prototype:\n"
    "unpack_double(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 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_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_string" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_string();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_string'.\n"
    "  Prototype:\n"
    "unpack_string(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_sparsity_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Sparsity,std::allocator< casadi::Sparsity > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_sparsity_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_sparsity_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Sparsity" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_sparsity_vector'.\n"
    "  Prototype:\n"
    "unpack_sparsity_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_mx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_mx_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_mx_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_mx_vector'.\n"
    "  Prototype:\n"
    "unpack_mx_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_dm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_dm_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_dm_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_dm_vector'.\n"
    "  Prototype:\n"
    "unpack_dm_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_sx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_sx_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_sx_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "SX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_sx_vector'.\n"
    "  Prototype:\n"
    "unpack_sx_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_linsol_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_linsol_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_linsol_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >(static_cast< const std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >& >(result))), SWIGTYPE_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_linsol_vector'.\n"
    "  Prototype:\n"
    "unpack_linsol_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_function_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::Function,std::allocator< casadi::Function > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_function_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_function_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "Function" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_function_vector'.\n"
    "  Prototype:\n"
    "unpack_function_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_generictype_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::GenericType,std::allocator< casadi::GenericType > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_generictype_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_generictype_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "GenericType" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_generictype_vector'.\n"
    "  Prototype:\n"
    "unpack_generictype_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_int_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi_int,std::allocator< casadi_int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_int_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_int_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "int" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_int_vector'.\n"
    "  Prototype:\n"
    "unpack_int_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_double_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_double_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_double_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "float" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_double_vector'.\n"
    "  Prototype:\n"
    "unpack_double_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_unpack_string_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_unpack_string_vector" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      result = (arg1)->unpack_string_vector();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "str" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_unpack_string_vector'.\n"
    "  Prototype:\n"
    "unpack_string_vector(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 0 ;
  casadi::SerializerBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"DeserializerBase_connect",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_connect" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__SerializerBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeserializerBase_connect" "', argument " "2"" of type '" "casadi::SerializerBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeserializerBase_connect" "', argument " "2"" of type '" "casadi::SerializerBase &""'"); 
  }
  arg2 = reinterpret_cast< casadi::SerializerBase * >(argp2);
  {
    try {
      (arg1)->connect(*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_connect'.\n"
    "  Prototype:\n"
    "connect(self,SerializerBase)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeserializerBase_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::DeserializerBase *arg1 = (casadi::DeserializerBase *) 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_casadi__DeserializerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeserializerBase_reset" "', argument " "1"" of type '" "casadi::DeserializerBase *""'"); 
  }
  arg1 = reinterpret_cast< casadi::DeserializerBase * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'DeserializerBase_reset'.\n"
    "  Prototype:\n"
    "reset(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StringSerializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Dict const &arg1_defvalue = casadi::Dict() ;
  casadi::Dict *arg1 = (casadi::Dict *) &arg1_defvalue ;
  std::map< std::string,casadi::GenericType > m1 ;
  PyObject *swig_obj[1] ;
  casadi::StringSerializer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_StringSerializer",0,1,swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    arg1 = &m1;
    if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::StringSerializer *)new casadi::StringSerializer((casadi::Dict const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__StringSerializer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_StringSerializer'.\n"
    "  Prototype:\n"
    "StringSerializer(dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringSerializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::StringSerializer *arg1 = (casadi::StringSerializer *) 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_casadi__StringSerializer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringSerializer" "', argument " "1"" of type '" "casadi::StringSerializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::StringSerializer * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_StringSerializer'.\n"
    "  Prototype:\n"
    "StringSerializer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSerializer_encode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::StringSerializer *arg1 = (casadi::StringSerializer *) 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_casadi__StringSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSerializer_encode" "', argument " "1"" of type '" "casadi::StringSerializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::StringSerializer * >(argp1);
  {
    try {
      result = (arg1)->encode();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'StringSerializer_encode'.\n"
    "  Prototype:\n"
    "encode(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FileSerializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  casadi::Dict const &arg2_defvalue = casadi::Dict() ;
  casadi::Dict *arg2 = (casadi::Dict *) &arg2_defvalue ;
  std::string m1 ;
  std::map< std::string,casadi::GenericType > m2 ;
  PyObject *swig_obj[2] ;
  casadi::FileSerializer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_FileSerializer",1,2,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  if (swig_obj[1]) {
    arg2 = &m2;
    if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" "'.");
  }
  {
    try {
      result = (casadi::FileSerializer *)new casadi::FileSerializer((std::string const &)*arg1,(casadi::Dict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__FileSerializer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_FileSerializer'.\n"
    "  Prototype:\n"
    "FileSerializer(str,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileSerializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FileSerializer *arg1 = (casadi::FileSerializer *) 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_casadi__FileSerializer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSerializer" "', argument " "1"" of type '" "casadi::FileSerializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FileSerializer * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_FileSerializer'.\n"
    "  Prototype:\n"
    "FileSerializer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StringDeserializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  casadi::StringDeserializer *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (casadi::StringDeserializer *)new casadi::StringDeserializer((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__StringDeserializer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_StringDeserializer'.\n"
    "  Prototype:\n"
    "StringDeserializer(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringDeserializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::StringDeserializer *arg1 = (casadi::StringDeserializer *) 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_casadi__StringDeserializer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringDeserializer" "', argument " "1"" of type '" "casadi::StringDeserializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::StringDeserializer * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_StringDeserializer'.\n"
    "  Prototype:\n"
    "StringDeserializer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringDeserializer_decode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::StringDeserializer *arg1 = (casadi::StringDeserializer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"StringDeserializer_decode",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__StringDeserializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringDeserializer_decode" "', argument " "1"" of type '" "casadi::StringDeserializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::StringDeserializer * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  {
    try {
      (arg1)->decode((std::string const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'StringDeserializer_decode'.\n"
    "  Prototype:\n"
    "decode(self,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FileDeserializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string m1 ;
  PyObject *swig_obj[1] ;
  casadi::FileDeserializer *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  {
    try {
      result = (casadi::FileDeserializer *)new casadi::FileDeserializer((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__FileDeserializer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'new_FileDeserializer'.\n"
    "  Prototype:\n"
    "FileDeserializer(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileDeserializer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::FileDeserializer *arg1 = (casadi::FileDeserializer *) 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_casadi__FileDeserializer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileDeserializer" "', argument " "1"" of type '" "casadi::FileDeserializer *""'"); 
  }
  arg1 = reinterpret_cast< casadi::FileDeserializer * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_FileDeserializer'.\n"
    "  Prototype:\n"
    "FileDeserializer(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Opti__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string const &arg1_defvalue = "nlp" ;
  std::string *arg1 = (std::string *) &arg1_defvalue ;
  std::string m1 ;
  casadi::Opti *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 1)) SWIG_fail;
  if (swig_obj[0]) {
    arg1 = &m1;
    if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "str" "'.");
  }
  {
    try {
      result = (casadi::Opti *)new casadi::Opti((std::string const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Opti, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Opti'.\n"
    "  Prototype:\n"
    "Opti(str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__variable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  std::string const &arg4_defvalue = "full" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m4 ;
  PyObject *swig_obj[4] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti__variable",1,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__variable" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->variable(arg2,arg3,(std::string const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__variable'.\n"
    "  Prototype:\n"
    "_variable(self,int,int,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__parameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi_int arg2 = (casadi_int) 1 ;
  casadi_int arg3 = (casadi_int) 1 ;
  std::string const &arg4_defvalue = "full" ;
  std::string *arg4 = (std::string *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m4 ;
  PyObject *swig_obj[4] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti__parameter",1,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__parameter" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  }
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "str" "'.");
  }
  {
    try {
      result = (arg1)->parameter(arg2,arg3,(std::string const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__parameter'.\n"
    "  Prototype:\n"
    "_parameter(self,int,int,str)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_minimize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_minimize",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_minimize" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      (arg1)->minimize((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_minimize'.\n"
    "  Prototype:\n"
    "minimize(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__subject_to__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__subject_to" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      (arg1)->subject_to((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__subject_to'.\n"
    "  Prototype:\n"
    "_subject_to(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__subject_to__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__subject_to" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      (arg1)->subject_to((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__subject_to'.\n"
    "  Prototype:\n"
    "_subject_to(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__subject_to__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__subject_to" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      (arg1)->subject_to();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__subject_to'.\n"
    "  Prototype:\n"
    "_subject_to(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__subject_to(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti__subject_to",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Opti__subject_to__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_Opti__subject_to__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_Opti__subject_to__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti__subject_to'.\n"
    "  Possible prototypes are:\n"
    "    _subject_to(self)\n"
    "    _subject_to(self,MX)\n"
    "    _subject_to(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::string *arg2 = 0 ;
  casadi::Dict const &arg3_defvalue = casadi::Dict() ;
  casadi::Dict *arg3 = (casadi::Dict *) &arg3_defvalue ;
  casadi::Dict const &arg4_defvalue = casadi::Dict() ;
  casadi::Dict *arg4 = (casadi::Dict *) &arg4_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  std::map< std::string,casadi::GenericType > m4 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_solver",2,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_solver" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  }
  if (swig_obj[3]) {
    arg4 = &m4;
    if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "dict" "'.");
  }
  {
    try {
      (arg1)->solver((std::string const &)*arg2,(casadi::Dict const &)*arg3,(casadi::Dict const &)*arg4);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_solver'.\n"
    "  Prototype:\n"
    "solver(self,str,dict,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_set_initial__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::DM *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_set_initial" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      (arg1)->set_initial((casadi::MX const &)*arg2,(casadi::DM const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_set_initial'.\n"
    "  Prototype:\n"
    "set_initial(self,MX,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_set_initial__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_set_initial" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      (arg1)->set_initial((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_set_initial'.\n"
    "  Prototype:\n"
    "set_initial(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_set_initial(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_set_initial",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_Opti_set_initial__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_Opti_set_initial__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_set_initial'.\n"
    "  Possible prototypes are:\n"
    "    set_initial(self,[MX])\n"
    "    set_initial(self,MX,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_set_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::DM *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  casadi::Matrix< double > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_set_value" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "DM" "'.");
  {
    try {
      (arg1)->set_value((casadi::MX const &)*arg2,(casadi::DM const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_set_value'.\n"
    "  Prototype:\n"
    "set_value(self,MX,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_set_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_set_value" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  {
    try {
      (arg1)->set_value((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_set_value'.\n"
    "  Prototype:\n"
    "set_value(self,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_set_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_set_value",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        return _wrap_Opti_set_value__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< casadi::Matrix<double> **>(0));
        if (_v) {
          return _wrap_Opti_set_value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_set_value'.\n"
    "  Possible prototypes are:\n"
    "    set_value(self,[MX])\n"
    "    set_value(self,MX,DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< casadi::OptiSol > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_solve" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (arg1)->solve();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::OptiSol(static_cast< const casadi::OptiSol& >(result))), SWIGTYPE_p_casadi__OptiSol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_solve'.\n"
    "  Prototype:\n"
    "solve(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_solve_limited(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< casadi::OptiSol > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_solve_limited" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (arg1)->solve_limited();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::OptiSol(static_cast< const casadi::OptiSol& >(result))), SWIGTYPE_p_casadi__OptiSol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_solve_limited'.\n"
    "  Prototype:\n"
    "solve_limited(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_value" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::Opti const *)arg1)->value((casadi::MX const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_value'.\n"
    "  Prototype:\n"
    "value(self,MX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::DM *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_value" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::Opti const *)arg1)->value((casadi::DM const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_value'.\n"
    "  Prototype:\n"
    "value(self,DM,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::SX *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_value" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::Opti const *)arg1)->value((casadi::SX const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_value'.\n"
    "  Prototype:\n"
    "value(self,SX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_value",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Opti_value__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_Opti_value__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Opti_value__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_Opti_value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_Opti_value__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_Opti_value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_value'.\n"
    "  Possible prototypes are:\n"
    "    value(self,DM,[MX])\n"
    "    value(self,SX,[MX])\n"
    "    value(self,MX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_stats" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->stats();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_stats'.\n"
    "  Prototype:\n"
    "stats(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_return_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 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_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_return_status" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->return_status();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_return_status'.\n"
    "  Prototype:\n"
    "return_status(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_initial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_initial" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->initial();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_initial'.\n"
    "  Prototype:\n"
    "initial(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value_variables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_value_variables" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->value_variables();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_value_variables'.\n"
    "  Prototype:\n"
    "value_variables(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_value_parameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_value_parameters" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->value_parameters();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_value_parameters'.\n"
    "  Prototype:\n"
    "value_parameters(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_dual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_dual",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_dual" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::Opti const *)arg1)->dual((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_dual'.\n"
    "  Prototype:\n"
    "dual(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__nx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__nx" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Opti const *)arg1)->nx();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__nx'.\n"
    "  Prototype:\n"
    "_nx(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__np(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__np" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Opti const *)arg1)->np();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__np'.\n"
    "  Prototype:\n"
    "_np(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__ng(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__ng" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::Opti const *)arg1)->ng();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__ng'.\n"
    "  Prototype:\n"
    "_ng(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__x" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->x();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__x'.\n"
    "  Prototype:\n"
    "_x(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__p" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->p();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__p'.\n"
    "  Prototype:\n"
    "_p(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__g" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->g();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__g'.\n"
    "  Prototype:\n"
    "_g(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__f" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->f();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__f'.\n"
    "  Prototype:\n"
    "_f(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__lbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__lbg" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->lbg();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__lbg'.\n"
    "  Prototype:\n"
    "_lbg(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__ubg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__ubg" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->ubg();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__ubg'.\n"
    "  Prototype:\n"
    "_ubg(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__lam_g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__lam_g" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->lam_g();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__lam_g'.\n"
    "  Prototype:\n"
    "_lam_g(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_to_function__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg4 = 0 ;
  casadi::Dict const &arg5_defvalue = casadi::Dict() ;
  casadi::Dict *arg5 = (casadi::Dict *) &arg5_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX > m4 ;
  std::map< std::string,casadi::GenericType > m5 ;
  casadi::Function result;
  
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_to_function" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "MX" "]" "'.");
  if (swig_obj[4]) {
    arg5 = &m5;
    if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->to_function((std::string const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg4,(casadi::Dict const &)*arg5);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_to_function'.\n"
    "  Prototype:\n"
    "to_function(self,str,[MX],[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_to_function__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg6 = 0 ;
  casadi::Dict const &arg7_defvalue = casadi::Dict() ;
  casadi::Dict *arg7 = (casadi::Dict *) &arg7_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::vector< casadi::MX > m3 ;
  std::vector< casadi::MX > m4 ;
  std::vector< std::string > m5 ;
  std::vector< std::string > m6 ;
  std::map< std::string,casadi::GenericType > m7 ;
  casadi::Function result;
  
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_to_function" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "MX" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  arg6 = &m6;
  if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "[" "str" "]" "'.");
  if (swig_obj[6]) {
    arg7 = &m7;
    if (!casadi::to_ptr(swig_obj[6], &arg7)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 7 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->to_function((std::string const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(std::vector< std::string,std::allocator< std::string > > const &)*arg6,(casadi::Dict const &)*arg7);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_to_function'.\n"
    "  Prototype:\n"
    "to_function(self,str,[MX],[MX],[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_to_function__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg5 = 0 ;
  casadi::Dict const &arg6_defvalue = casadi::Dict() ;
  casadi::Dict *arg6 = (casadi::Dict *) &arg6_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string m2 ;
  std::map< std::string,casadi::MX > m3 ;
  std::vector< std::string > m4 ;
  std::vector< std::string > m5 ;
  std::map< std::string,casadi::GenericType > m6 ;
  casadi::Function result;
  
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_to_function" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "str" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" ":" "MX" "'.");
  arg4 = &m4;
  if (!casadi::to_ptr(swig_obj[3], &arg4)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 4 to type '" "[" "str" "]" "'.");
  arg5 = &m5;
  if (!casadi::to_ptr(swig_obj[4], &arg5)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 5 to type '" "[" "str" "]" "'.");
  if (swig_obj[5]) {
    arg6 = &m6;
    if (!casadi::to_ptr(swig_obj[5], &arg6)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 6 to type '" "dict" "'.");
  }
  {
    try {
      result = (arg1)->to_function((std::string const &)*arg2,(std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4,(std::vector< std::string,std::allocator< std::string > > const &)*arg5,(casadi::Dict const &)*arg6);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_to_function'.\n"
    "  Prototype:\n"
    "to_function(self,str,dict:MX,[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_to_function(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_to_function",0,7,argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 5)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi::MX> **>(0));
          if (_v) {
            if (argc <= 4) {
              return _wrap_Opti_to_function__SWIG_0(self, argc, argv);
            }
            _v = casadi::to_ptr(argv[4], static_cast< std::map<std::string,casadi::GenericType> **>(0));
            if (_v) {
              return _wrap_Opti_to_function__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<std::string> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              if (argc <= 5) {
                return _wrap_Opti_to_function__SWIG_2(self, argc, argv);
              }
              _v = casadi::to_ptr(argv[5], static_cast< std::map<std::string,casadi::GenericType> **>(0));
              if (_v) {
                return _wrap_Opti_to_function__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::string **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          _v = casadi::to_ptr(argv[3], static_cast< std::vector<casadi::MX> **>(0));
          if (_v) {
            _v = casadi::to_ptr(argv[4], static_cast< std::vector<std::string> **>(0));
            if (_v) {
              _v = casadi::to_ptr(argv[5], static_cast< std::vector<std::string> **>(0));
              if (_v) {
                if (argc <= 6) {
                  return _wrap_Opti_to_function__SWIG_1(self, argc, argv);
                }
                _v = casadi::to_ptr(argv[6], static_cast< std::map<std::string,casadi::GenericType> **>(0));
                if (_v) {
                  return _wrap_Opti_to_function__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_to_function'.\n"
    "  Possible prototypes are:\n"
    "    to_function(self,str,[MX],[MX],dict)\n"
    "    to_function(self,str,dict:MX,[str],[str],dict)\n"
    "    to_function(self,str,[MX],[MX],[str],[str],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_bounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MX *arg1 = 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MX *arg3 = 0 ;
  casadi::MX m1 ;
  casadi::MX m2 ;
  casadi::MX m3 ;
  PyObject *swig_obj[3] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_bounded",3,3,swig_obj)) SWIG_fail;
  arg1 = &m1;
  if (!casadi::to_ptr(swig_obj[0], &arg1)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 1 to type '" "MX" "'.");
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "MX" "'.");
  {
    try {
      result = casadi::Opti::bounded((casadi::MX const &)*arg1,(casadi::MX const &)*arg2,(casadi::MX const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_bounded'.\n"
    "  Prototype:\n"
    "bounded(MX,MX,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< casadi::OptiAdvanced > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__debug" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->debug();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::OptiAdvanced(static_cast< const casadi::OptiAdvanced& >(result))), SWIGTYPE_p_casadi__OptiAdvanced, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__debug'.\n"
    "  Prototype:\n"
    "_debug(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti__advanced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< casadi::OptiAdvanced > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti__advanced" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->advanced();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::OptiAdvanced(static_cast< const casadi::OptiAdvanced& >(result))), SWIGTYPE_p_casadi__OptiAdvanced, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti__advanced'.\n"
    "  Prototype:\n"
    "_advanced(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Opti result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_copy" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->copy();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::Opti(static_cast< const casadi::Opti& >(result))), SWIGTYPE_p_casadi__Opti, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_copy'.\n"
    "  Prototype:\n"
    "copy(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_update_user_dict__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::Dict *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_update_user_dict" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  {
    try {
      (arg1)->update_user_dict((casadi::MX const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_update_user_dict'.\n"
    "  Prototype:\n"
    "update_user_dict(self,MX,dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_update_user_dict__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg2 = 0 ;
  casadi::Dict *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX > m2 ;
  std::map< std::string,casadi::GenericType > m3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_update_user_dict" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "[" "MX" "]" "'.");
  arg3 = &m3;
  if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "dict" "'.");
  {
    try {
      (arg1)->update_user_dict((std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg2,(casadi::Dict const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_update_user_dict'.\n"
    "  Prototype:\n"
    "update_user_dict(self,[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_update_user_dict(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_update_user_dict",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Opti_update_user_dict__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::vector<casadi::MX> **>(0));
      if (_v) {
        _v = casadi::to_ptr(argv[2], static_cast< std::map<std::string,casadi::GenericType> **>(0));
        if (_v) {
          return _wrap_Opti_update_user_dict__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_update_user_dict'.\n"
    "  Possible prototypes are:\n"
    "    update_user_dict(self,MX,dict)\n"
    "    update_user_dict(self,[MX],dict)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_Opti_user_dict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::Dict result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_user_dict",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_user_dict" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::Opti const *)arg1)->user_dict((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_user_dict'.\n"
    "  Prototype:\n"
    "user_dict(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 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_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_type_name" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = ((casadi::Opti const *)arg1)->type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_type_name'.\n"
    "  Prototype:\n"
    "type_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"Opti_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_disp" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::Opti const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"Opti_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_str" "', argument " "1"" of type '" "casadi::Opti const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::Opti const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_callback_class__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  casadi::OptiCallback *arg2 = (casadi::OptiCallback *) 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_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_callback_class" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_casadi__OptiCallback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Opti_callback_class" "', argument " "2"" of type '" "casadi::OptiCallback *""'"); 
  }
  arg2 = reinterpret_cast< casadi::OptiCallback * >(argp2);
  {
    try {
      (arg1)->callback_class(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_callback_class'.\n"
    "  Prototype:\n"
    "callback_class(self,OptiCallback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_callback_class__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__Opti, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opti_callback_class" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      (arg1)->callback_class();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'Opti_callback_class'.\n"
    "  Prototype:\n"
    "callback_class(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Opti_callback_class(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"Opti_callback_class",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Opti_callback_class__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_casadi__OptiCallback, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Opti_callback_class__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'Opti_callback_class'.\n"
    "  Possible prototypes are:\n"
    "    callback_class(self)\n"
    "    callback_class(self,OptiCallback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Opti__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Opti *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__Opti,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Opti" "', argument " "1"" of type '" "casadi::Opti const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Opti" "', argument " "1"" of type '" "casadi::Opti const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    result = (casadi::Opti *)new casadi::Opti((casadi::Opti const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__Opti, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_Opti'.\n"
    "  Prototype:\n"
    "Opti(Opti)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Opti(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Opti",0,1,argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 1)) {
    int _v;
    if (argc <= 0) {
      return _wrap_new_Opti__SWIG_0(self, argc, argv);
    }
    _v = casadi::to_ptr(argv[0], static_cast< std::string **>(0));
    if (_v) {
      return _wrap_new_Opti__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Opti__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_Opti'.\n"
    "  Possible prototypes are:\n"
    "    Opti(str)\n"
    "    Opti(Opti)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Opti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = (casadi::Opti *) 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_casadi__Opti, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Opti" "', argument " "1"" of type '" "casadi::Opti *""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_Opti'.\n"
    "  Prototype:\n"
    "Opti(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IndexAbstraction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::IndexAbstraction *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::IndexAbstraction *)new casadi::IndexAbstraction();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__IndexAbstraction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_IndexAbstraction'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexAbstraction_start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::IndexAbstraction *arg1 = (casadi::IndexAbstraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__IndexAbstraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexAbstraction_start_get" "', argument " "1"" of type '" "casadi::IndexAbstraction *""'"); 
  }
  arg1 = reinterpret_cast< casadi::IndexAbstraction * >(argp1);
  result = (casadi_int) ((arg1)->start);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'IndexAbstraction_start_get'.\n"
    "  Prototype:\n"
    "IndexAbstraction_start_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexAbstraction_stop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::IndexAbstraction *arg1 = (casadi::IndexAbstraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__IndexAbstraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexAbstraction_stop_get" "', argument " "1"" of type '" "casadi::IndexAbstraction *""'"); 
  }
  arg1 = reinterpret_cast< casadi::IndexAbstraction * >(argp1);
  result = (casadi_int) ((arg1)->stop);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'IndexAbstraction_stop_get'.\n"
    "  Prototype:\n"
    "IndexAbstraction_stop_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndexAbstraction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::IndexAbstraction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::IndexAbstraction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__IndexAbstraction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IndexAbstraction" "', argument " "1"" of type '" "casadi::IndexAbstraction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexAbstraction" "', argument " "1"" of type '" "casadi::IndexAbstraction const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::IndexAbstraction * >(argp1);
  {
    result = (casadi::IndexAbstraction *)new casadi::IndexAbstraction((casadi::IndexAbstraction const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__IndexAbstraction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_IndexAbstraction'.\n"
    "  Prototype:\n"
    "IndexAbstraction(IndexAbstraction)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndexAbstraction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_IndexAbstraction",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IndexAbstraction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__IndexAbstraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndexAbstraction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_IndexAbstraction'.\n"
    "  Possible prototypes are:\n"
    "    IndexAbstraction()\n"
    "    IndexAbstraction(IndexAbstraction)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IndexAbstraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::IndexAbstraction *arg1 = (casadi::IndexAbstraction *) 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_casadi__IndexAbstraction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndexAbstraction" "', argument " "1"" of type '" "casadi::IndexAbstraction *""'"); 
  }
  arg1 = reinterpret_cast< casadi::IndexAbstraction * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_IndexAbstraction'.\n"
    "  Prototype:\n"
    "IndexAbstraction(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MetaCon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::MetaCon *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (casadi::MetaCon *)new casadi::MetaCon();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MetaCon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_MetaCon'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_original_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_original_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->original);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_original_get'.\n"
    "  Prototype:\n"
    "MetaCon_original_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_canon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_canon_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->canon);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_canon_get'.\n"
    "  Prototype:\n"
    "MetaCon_canon_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::ConstraintType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_type_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::ConstraintType) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_type_get'.\n"
    "  Prototype:\n"
    "MetaCon_type_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_lb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_lb_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->lb);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_lb_get'.\n"
    "  Prototype:\n"
    "MetaCon_lb_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_ub_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_ub_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->ub);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_ub_get'.\n"
    "  Prototype:\n"
    "MetaCon_ub_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_n_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi_int) ((arg1)->n);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_n_get'.\n"
    "  Prototype:\n"
    "MetaCon_n_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_flipped_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 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_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_flipped_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (bool) ((arg1)->flipped);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_flipped_get'.\n"
    "  Prototype:\n"
    "MetaCon_flipped_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_dual_canon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_dual_canon_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->dual_canon);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_dual_canon_get'.\n"
    "  Prototype:\n"
    "MetaCon_dual_canon_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_dual_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_dual_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::MX *) & ((arg1)->dual);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_dual_get'.\n"
    "  Prototype:\n"
    "MetaCon_dual_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaCon_extra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaCon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaCon_extra_get" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  result = (casadi::Dict *) & ((arg1)->extra);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaCon_extra_get'.\n"
    "  Prototype:\n"
    "MetaCon_extra_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MetaCon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MetaCon *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__MetaCon,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MetaCon" "', argument " "1"" of type '" "casadi::MetaCon const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MetaCon" "', argument " "1"" of type '" "casadi::MetaCon const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  {
    result = (casadi::MetaCon *)new casadi::MetaCon((casadi::MetaCon const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MetaCon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MetaCon'.\n"
    "  Prototype:\n"
    "MetaCon(MetaCon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MetaCon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MetaCon",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MetaCon__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__MetaCon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MetaCon__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_MetaCon'.\n"
    "  Possible prototypes are:\n"
    "    MetaCon()\n"
    "    MetaCon(MetaCon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MetaCon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaCon *arg1 = (casadi::MetaCon *) 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_casadi__MetaCon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaCon" "', argument " "1"" of type '" "casadi::MetaCon *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaCon * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_MetaCon'.\n"
    "  Prototype:\n"
    "MetaCon(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_MetaVar_attribute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 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_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_attribute_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (std::string *) & ((arg1)->attribute);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_attribute_get'.\n"
    "  Prototype:\n"
    "MetaVar_attribute_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_n_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi_int) ((arg1)->n);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_n_get'.\n"
    "  Prototype:\n"
    "MetaVar_n_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_m_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi_int) ((arg1)->m);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_m_get'.\n"
    "  Prototype:\n"
    "MetaVar_m_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::VariableType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_type_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi::VariableType) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_type_get'.\n"
    "  Prototype:\n"
    "MetaVar_type_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_count_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi_int) ((arg1)->count);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_count_get'.\n"
    "  Prototype:\n"
    "MetaVar_count_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_i_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi_int) ((arg1)->i);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_i_get'.\n"
    "  Prototype:\n"
    "MetaVar_i_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_active_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_active_i_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi_int) ((arg1)->active_i);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_active_i_get'.\n"
    "  Prototype:\n"
    "MetaVar_active_i_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MetaVar_extra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__MetaVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaVar_extra_get" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  result = (casadi::Dict *) & ((arg1)->extra);
  if(!(resultobj = casadi::from_ptr(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'MetaVar_extra_get'.\n"
    "  Prototype:\n"
    "MetaVar_extra_get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MetaVar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  casadi::MetaVar *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    result = (casadi::MetaVar *)new casadi::MetaVar();
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MetaVar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    SWIG_SetErrorMsg(PyExc_NotImplementedError, "Received too many arguments for function 'new_MetaVar'.");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MetaVar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MetaVar *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__MetaVar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MetaVar" "', argument " "1"" of type '" "casadi::MetaVar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MetaVar" "', argument " "1"" of type '" "casadi::MetaVar const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  {
    result = (casadi::MetaVar *)new casadi::MetaVar((casadi::MetaVar const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__MetaVar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_MetaVar'.\n"
    "  Prototype:\n"
    "MetaVar(MetaVar)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MetaVar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MetaVar",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MetaVar__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__MetaVar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MetaVar__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_MetaVar'.\n"
    "  Possible prototypes are:\n"
    "    MetaVar()\n"
    "    MetaVar(MetaVar)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MetaVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::MetaVar *arg1 = (casadi::MetaVar *) 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_casadi__MetaVar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaVar" "', argument " "1"" of type '" "casadi::MetaVar *""'"); 
  }
  arg1 = reinterpret_cast< casadi::MetaVar * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_MetaVar'.\n"
    "  Prototype:\n"
    "MetaVar(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OptiCallback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  casadi::OptiCallback *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (casadi::OptiCallback *)new SwigDirector_OptiCallback(arg1); 
      } else {
        result = (casadi::OptiCallback *)new casadi::OptiCallback(); 
      }
      
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__OptiCallback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_OptiCallback'.\n"
    "  Prototype:\n"
    "OptiCallback(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiCallback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  casadi::OptiCallback *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  casadi::OptiCallback *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_casadi__OptiCallback,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OptiCallback" "', argument " "2"" of type '" "casadi::OptiCallback const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptiCallback" "', argument " "2"" of type '" "casadi::OptiCallback const &""'"); 
  }
  arg2 = reinterpret_cast< casadi::OptiCallback * >(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (casadi::OptiCallback *)new SwigDirector_OptiCallback(arg1,(casadi::OptiCallback const &)*arg2); 
      } else {
        result = (casadi::OptiCallback *)new casadi::OptiCallback((casadi::OptiCallback const &)*arg2); 
      }
      
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__OptiCallback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_OptiCallback'.\n"
    "  Prototype:\n"
    "OptiCallback(self,OptiCallback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_OptiCallback",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_OptiCallback__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_casadi__OptiCallback, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_OptiCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_OptiCallback'.\n"
    "  Possible prototypes are:\n"
    "    OptiCallback(self)\n"
    "    OptiCallback(self,OptiCallback)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_OptiCallback_call(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiCallback *arg1 = (casadi::OptiCallback *) 0 ;
  casadi_int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiCallback_call",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiCallback_call" "', argument " "1"" of type '" "casadi::OptiCallback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiCallback * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->casadi::OptiCallback::call(arg2);
        } else {
          (arg1)->call(arg2);
        }
      } catch(const std::exception& e) {
        SWIG_exception(SWIG_RuntimeError, e.what());
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiCallback_call'.\n"
    "  Prototype:\n"
    "call(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OptiCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiCallback *arg1 = (casadi::OptiCallback *) 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_casadi__OptiCallback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptiCallback" "', argument " "1"" of type '" "casadi::OptiCallback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiCallback * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_OptiCallback'.\n"
    "  Prototype:\n"
    "OptiCallback(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_OptiCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiCallback *arg1 = (casadi::OptiCallback *) 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_casadi__OptiCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_OptiCallback" "', argument " "1"" of type '" "casadi::OptiCallback *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiCallback * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OptiAdvanced__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::Opti *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::OptiAdvanced *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__Opti,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptiAdvanced" "', argument " "1"" of type '" "casadi::Opti const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptiAdvanced" "', argument " "1"" of type '" "casadi::Opti const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::Opti * >(argp1);
  {
    try {
      result = (casadi::OptiAdvanced *)new casadi::OptiAdvanced((casadi::Opti const &)*arg1);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__OptiAdvanced, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_OptiAdvanced'.\n"
    "  Prototype:\n"
    "OptiAdvanced(Opti)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OptiAdvanced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptiAdvanced" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      delete arg1;
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_OptiAdvanced'.\n"
    "  Prototype:\n"
    "OptiAdvanced(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced__casadi_solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Function result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced__casadi_solver" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->casadi_solver();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "Function" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced__casadi_solver'.\n"
    "  Prototype:\n"
    "_casadi_solver(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_is_parametric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_is_parametric",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_is_parametric" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = (bool)((casadi::OptiAdvanced const *)arg1)->is_parametric((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_is_parametric'.\n"
    "  Prototype:\n"
    "is_parametric(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_symvar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_symvar" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->symvar();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_symvar'.\n"
    "  Prototype:\n"
    "symvar(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_symvar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_symvar" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->symvar((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_symvar'.\n"
    "  Prototype:\n"
    "symvar(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_symvar__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::VariableType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  int val3 ;
  int ecode3 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_symvar" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptiAdvanced_symvar" "', argument " "3"" of type '" "casadi::VariableType""'");
  } 
  arg3 = static_cast< casadi::VariableType >(val3);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->symvar((casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_symvar'.\n"
    "  Prototype:\n"
    "symvar(self,MX,casadi::VariableType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_symvar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"OptiAdvanced_symvar",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_OptiAdvanced_symvar__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        return _wrap_OptiAdvanced_symvar__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptiAdvanced_symvar__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'OptiAdvanced_symvar'.\n"
    "  Possible prototypes are:\n"
    "    symvar(self)\n"
    "    symvar(self,MX)\n"
    "    symvar(self,MX,casadi::VariableType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_canon_expr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MetaCon result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_canon_expr",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_canon_expr" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->canon_expr((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::MetaCon(static_cast< const casadi::MetaCon& >(result))), SWIGTYPE_p_casadi__MetaCon, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_canon_expr'.\n"
    "  Prototype:\n"
    "canon_expr(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_get_meta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MetaVar result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_get_meta",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_get_meta" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->get_meta((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::MetaVar(static_cast< const casadi::MetaVar& >(result))), SWIGTYPE_p_casadi__MetaVar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_get_meta'.\n"
    "  Prototype:\n"
    "get_meta(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_get_meta_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  casadi::MetaCon result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_get_meta_con",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_get_meta_con" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->get_meta_con((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::MetaCon(static_cast< const casadi::MetaCon& >(result))), SWIGTYPE_p_casadi__MetaCon, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_get_meta_con'.\n"
    "  Prototype:\n"
    "get_meta_con(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_set_meta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MetaVar *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_set_meta",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_set_meta" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_casadi__MetaVar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptiAdvanced_set_meta" "', argument " "3"" of type '" "casadi::MetaVar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptiAdvanced_set_meta" "', argument " "3"" of type '" "casadi::MetaVar const &""'"); 
  }
  arg3 = reinterpret_cast< casadi::MetaVar * >(argp3);
  {
    try {
      (arg1)->set_meta((casadi::MX const &)*arg2,(casadi::MetaVar const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_set_meta'.\n"
    "  Prototype:\n"
    "set_meta(self,MX,MetaVar)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_set_meta_con(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi::MetaCon *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_set_meta_con",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_set_meta_con" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_casadi__MetaCon,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptiAdvanced_set_meta_con" "', argument " "3"" of type '" "casadi::MetaCon const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptiAdvanced_set_meta_con" "', argument " "3"" of type '" "casadi::MetaCon const &""'"); 
  }
  arg3 = reinterpret_cast< casadi::MetaCon * >(argp3);
  {
    try {
      (arg1)->set_meta_con((casadi::MX const &)*arg2,(casadi::MetaCon const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_set_meta_con'.\n"
    "  Prototype:\n"
    "set_meta_con(self,MX,MetaCon)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_assert_active_symbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_assert_active_symbol",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_assert_active_symbol" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  {
    try {
      ((casadi::OptiAdvanced const *)arg1)->assert_active_symbol((casadi::MX const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_assert_active_symbol'.\n"
    "  Prototype:\n"
    "assert_active_symbol(self,MX)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_active_symvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::VariableType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_active_symvar",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_active_symvar" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptiAdvanced_active_symvar" "', argument " "2"" of type '" "casadi::VariableType""'");
  } 
  arg2 = static_cast< casadi::VariableType >(val2);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->active_symvar(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_active_symvar'.\n"
    "  Prototype:\n"
    "active_symvar(self,casadi::VariableType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_active_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::VariableType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< casadi::DM,std::allocator< casadi::DM > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_active_values",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_active_values" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptiAdvanced_active_values" "', argument " "2"" of type '" "casadi::VariableType""'");
  } 
  arg2 = static_cast< casadi::VariableType >(val2);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->active_values(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "DM" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_active_values'.\n"
    "  Prototype:\n"
    "active_values(self,casadi::VariableType)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_x_lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi_index arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_x_lookup",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_x_lookup" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->x_lookup(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_x_lookup'.\n"
    "  Prototype:\n"
    "x_lookup(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_g_lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi_index arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  casadi::MX result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_g_lookup",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_g_lookup" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->g_lookup(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_g_lookup'.\n"
    "  Prototype:\n"
    "g_lookup(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_x_describe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi_index arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_x_describe",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_x_describe" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->x_describe(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_x_describe'.\n"
    "  Prototype:\n"
    "x_describe(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_g_describe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi_index arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_g_describe",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_g_describe" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "int" "'.");
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->g_describe(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_g_describe'.\n"
    "  Prototype:\n"
    "g_describe(self,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_describe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::MX *arg2 = 0 ;
  casadi_index arg3 = (casadi_index) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  PyObject *swig_obj[3] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_describe",2,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_describe" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    if (!casadi::to_val(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "int" "'.");
  }
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->describe((casadi::MX const &)*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_describe'.\n"
    "  Prototype:\n"
    "describe(self,MX,int)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_show_infeasibilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  double arg2 = (double) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_show_infeasibilities",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_show_infeasibilities" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "float" "'.");
  }
  {
    try {
      ((casadi::OptiAdvanced const *)arg1)->show_infeasibilities(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_show_infeasibilities'.\n"
    "  Prototype:\n"
    "show_infeasibilities(self,float)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solve_prepare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solve_prepare" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      (arg1)->solve_prepare();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solve_prepare'.\n"
    "  Prototype:\n"
    "solve_prepare(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solve_actual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::DMDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< double > > m2 ;
  PyObject *swig_obj[2] ;
  casadi::DMDict result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_solve_actual",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solve_actual" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "DM" "'.");
  {
    try {
      result = (arg1)->solve_actual((casadi::DMDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solve_actual'.\n"
    "  Prototype:\n"
    "solve_actual(self,dict:DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::DMDict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_arg" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->arg();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_arg'.\n"
    "  Prototype:\n"
    "arg(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_res__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  casadi::DMDict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< std::string,casadi::Matrix< double > > m2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_res" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "dict" ":" "DM" "'.");
  {
    try {
      (arg1)->res((casadi::DMDict const &)*arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_res'.\n"
    "  Prototype:\n"
    "res(self,dict:DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_res__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::DMDict result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_res" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->res();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" ":" "DM" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_res'.\n"
    "  Prototype:\n"
    "res(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_res(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"OptiAdvanced_res",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_OptiAdvanced_res__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< std::map<std::string,casadi::Matrix<double> > **>(0));
      if (_v) {
        return _wrap_OptiAdvanced_res__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'OptiAdvanced_res'.\n"
    "  Possible prototypes are:\n"
    "    res(self)\n"
    "    res(self,dict:DM)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_constraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_constraints" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->constraints();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_constraints'.\n"
    "  Prototype:\n"
    "constraints(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_objective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::MX result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_objective" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->objective();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "MX" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_objective'.\n"
    "  Prototype:\n"
    "objective(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_baked_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< casadi::OptiAdvanced > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_baked_copy" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = ((casadi::OptiAdvanced const *)arg1)->baked_copy();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::OptiAdvanced(static_cast< const casadi::OptiAdvanced& >(result))), SWIGTYPE_p_casadi__OptiAdvanced, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_baked_copy'.\n"
    "  Prototype:\n"
    "baked_copy(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_assert_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_assert_empty" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      ((casadi::OptiAdvanced const *)arg1)->assert_empty();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_assert_empty'.\n"
    "  Prototype:\n"
    "assert_empty(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_bake(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_bake" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      (arg1)->bake();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_bake'.\n"
    "  Prototype:\n"
    "bake(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_problem_dirty__get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_problem_dirty__get" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  result = (bool) ((arg1)->problem_dirty_);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_problem_dirty__get'.\n"
    "  Prototype:\n"
    "OptiAdvanced_problem_dirty__get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_mark_problem_dirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_mark_problem_dirty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_mark_problem_dirty" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->mark_problem_dirty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_mark_problem_dirty'.\n"
    "  Prototype:\n"
    "mark_problem_dirty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_problem_dirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_problem_dirty" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = (bool)((casadi::OptiAdvanced const *)arg1)->problem_dirty();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_problem_dirty'.\n"
    "  Prototype:\n"
    "problem_dirty(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solver_dirty__get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solver_dirty__get" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  result = (bool) ((arg1)->solver_dirty_);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solver_dirty__get'.\n"
    "  Prototype:\n"
    "OptiAdvanced_solver_dirty__get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_mark_solver_dirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_mark_solver_dirty",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_mark_solver_dirty" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->mark_solver_dirty(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_mark_solver_dirty'.\n"
    "  Prototype:\n"
    "mark_solver_dirty(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solver_dirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solver_dirty" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = (bool)((casadi::OptiAdvanced const *)arg1)->solver_dirty();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solver_dirty'.\n"
    "  Prototype:\n"
    "solver_dirty(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solved__get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solved__get" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  result = (bool) ((arg1)->solved_);
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solved__get'.\n"
    "  Prototype:\n"
    "OptiAdvanced_solved__get(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_mark_solved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiAdvanced_mark_solved",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_mark_solved" "', argument " "1"" of type '" "casadi::OptiAdvanced *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      (arg1)->mark_solved(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_mark_solved'.\n"
    "  Prototype:\n"
    "mark_solved(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_solved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_solved" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = (bool)((casadi::OptiAdvanced const *)arg1)->solved();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "bool" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_solved'.\n"
    "  Prototype:\n"
    "solved(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_assert_solved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_assert_solved" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      ((casadi::OptiAdvanced const *)arg1)->assert_solved();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_assert_solved'.\n"
    "  Prototype:\n"
    "assert_solved(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_assert_baked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 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_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_assert_baked" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      ((casadi::OptiAdvanced const *)arg1)->assert_baked();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_assert_baked'.\n"
    "  Prototype:\n"
    "assert_baked(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiAdvanced_instance_number(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = (casadi::OptiAdvanced *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi_int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiAdvanced, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiAdvanced_instance_number" "', argument " "1"" of type '" "casadi::OptiAdvanced const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    try {
      result = (casadi_int)((casadi::OptiAdvanced const *)arg1)->instance_number();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "int" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiAdvanced_instance_number'.\n"
    "  Prototype:\n"
    "instance_number(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiAdvanced__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiAdvanced *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::OptiAdvanced *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__OptiAdvanced,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptiAdvanced" "', argument " "1"" of type '" "casadi::OptiAdvanced const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptiAdvanced" "', argument " "1"" of type '" "casadi::OptiAdvanced const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiAdvanced * >(argp1);
  {
    result = (casadi::OptiAdvanced *)new casadi::OptiAdvanced((casadi::OptiAdvanced const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__OptiAdvanced, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_OptiAdvanced'.\n"
    "  Prototype:\n"
    "OptiAdvanced(OptiAdvanced)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiAdvanced(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_OptiAdvanced",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__OptiAdvanced, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptiAdvanced__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__Opti, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptiAdvanced__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_OptiAdvanced'.\n"
    "  Possible prototypes are:\n"
    "    OptiAdvanced(OptiAdvanced)\n"
    "    OptiAdvanced(Opti)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


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

SWIGINTERN PyObject *_wrap_OptiSol_type_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 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_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_type_name" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->type_name();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_type_name'.\n"
    "  Prototype:\n"
    "type_name(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_disp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &casadi::uout();
  if (!SWIG_Python_UnpackTuple(args,"OptiSol_disp",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_disp" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "bool" "'.");
  }
  {
    try {
      ((casadi::OptiSol const *)arg1)->disp(*arg2,arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_disp'.\n"
    "  Prototype:\n"
    "disp(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args,"OptiSol_str",1,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_str" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  if (swig_obj[1]) {
    if (!casadi::to_val(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "bool" "'.");
  }
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->get_str(arg2);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "str" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_str'.\n"
    "  Prototype:\n"
    "str(self,bool)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  casadi::MX *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::MX m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_value" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "MX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->value((casadi::MX const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_value'.\n"
    "  Prototype:\n"
    "value(self,MX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  casadi::DM *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< double > m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_value" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "DM" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->value((casadi::DM const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_value'.\n"
    "  Prototype:\n"
    "value(self,DM,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  casadi::SX *arg2 = 0 ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > const &arg3_defvalue = std::vector< casadi::MX >() ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > *arg3 = (std::vector< casadi::MX,std::allocator< casadi::MX > > *) &arg3_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::Matrix< casadi::SXElem > m2 ;
  std::vector< casadi::MX > m3 ;
  casadi::native_DM result;
  
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_value" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  arg2 = &m2;
  if (!casadi::to_ptr(swig_obj[1], &arg2)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 2 to type '" "SX" "'.");
  if (swig_obj[2]) {
    arg3 = &m3;
    if (!casadi::to_ptr(swig_obj[2], &arg3)) SWIG_exception_fail(SWIG_TypeError,"Failed to convert input 3 to type '" "[" "MX" "]" "'.");
  }
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->value((casadi::SX const &)*arg2,(std::vector< casadi::MX,std::allocator< casadi::MX > > const &)*arg3);
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = full_or_sparse(result, true))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type 'double'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_value'.\n"
    "  Prototype:\n"
    "value(self,SX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"OptiSol_value",0,3,argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiSol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<double> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_OptiSol_value__SWIG_1(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_OptiSol_value__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiSol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::Matrix<casadi::SXElem> **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_OptiSol_value__SWIG_2(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_OptiSol_value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_casadi__OptiSol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = casadi::to_ptr(argv[1], static_cast< casadi::MX **>(0));
      if (_v) {
        if (argc <= 2) {
          return _wrap_OptiSol_value__SWIG_0(self, argc, argv);
        }
        _v = casadi::to_ptr(argv[2], static_cast< std::vector<casadi::MX> **>(0));
        if (_v) {
          return _wrap_OptiSol_value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'OptiSol_value'.\n"
    "  Possible prototypes are:\n"
    "    value(self,DM,[MX])\n"
    "    value(self,SX,[MX])\n"
    "    value(self,MX,[MX])\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_OptiSol_value_variables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_value_variables" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->value_variables();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_value_variables'.\n"
    "  Prototype:\n"
    "value_variables(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_value_parameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< casadi::MX,std::allocator< casadi::MX > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_value_parameters" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->value_parameters();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "[" "MX" "]" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_value_parameters'.\n"
    "  Prototype:\n"
    "value_parameters(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol_stats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Dict result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol_stats" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->stats();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if(!(resultobj = casadi::from_ref(result))) SWIG_exception_fail(SWIG_TypeError,"Failed to convert output to type '" "dict" "'.");
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol_stats'.\n"
    "  Prototype:\n"
    "stats(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptiSol__opti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  casadi::Opti result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_casadi__OptiSol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptiSol__opti" "', argument " "1"" of type '" "casadi::OptiSol const *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    try {
      result = ((casadi::OptiSol const *)arg1)->opti();
    } catch(const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new casadi::Opti(static_cast< const casadi::Opti& >(result))), SWIGTYPE_p_casadi__Opti, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'OptiSol__opti'.\n"
    "  Prototype:\n"
    "_opti(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiSol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  casadi::OptiSol *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_casadi__OptiSol,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptiSol" "', argument " "1"" of type '" "casadi::OptiSol const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptiSol" "', argument " "1"" of type '" "casadi::OptiSol const &""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    result = (casadi::OptiSol *)new casadi::OptiSol((casadi::OptiSol const &)*arg1);
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_casadi__OptiSol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc_funpack(nobjs, swig_obj);
    std::string error_str = "Wrong number or type of arguments for function 'new_OptiSol'.\n"
    "  Prototype:\n"
    "OptiSol(OptiSol)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptiSol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_OptiSol",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_casadi__OptiSol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptiSol__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for overloaded function 'new_OptiSol'.\n"
    "  Possible prototypes are:\n"
    "    OptiSol(OptiSol)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptiSol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  casadi::OptiSol *arg1 = (casadi::OptiSol *) 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_casadi__OptiSol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptiSol" "', argument " "1"" of type '" "casadi::OptiSol *""'"); 
  }
  arg1 = reinterpret_cast< casadi::OptiSol * >(argp1);
  {
    delete arg1;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
    const char *res_char = SWIG_Python_ArgsTypeDesc(args);
    std::string error_str = "Wrong number or type of arguments for function 'delete_OptiSol'.\n"
    "  Prototype:\n"
    "OptiSol(self)\n"
    
    "  You have: " +  (res_char ? std::string(res_char) : "") + "\n";
    if (res_char) {
      SWIG_Python_str_DelForPy3(res_char); 
    }
    SWIG_SetErrorMsg(PyExc_NotImplementedError, error_str.c_str());
  }
  return NULL;
}


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

static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"delete_SwigPyIterator", (PyCFunction)_wrap_delete_SwigPyIterator, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  SwigPyIterator(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_value", (PyCFunction)_wrap_SwigPyIterator_value, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  value(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  incr(self, size_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  decr(self, size_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  distance(self, SwigPyIterator x) -> ptrdiff_t\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  equal(self, SwigPyIterator x) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_copy", (PyCFunction)_wrap_SwigPyIterator_copy, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  copy(self) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_next", (PyCFunction)_wrap_SwigPyIterator_next, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  next(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___next__", (PyCFunction)_wrap_SwigPyIterator___next__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __next__(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_previous", (PyCFunction)_wrap_SwigPyIterator_previous, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  previous(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  advance(self, ptrdiff_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __eq__(self, SwigPyIterator x) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __ne__(self, SwigPyIterator x) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __iadd__(self, ptrdiff_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __isub__(self, ptrdiff_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __add__(self, ptrdiff_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __sub__(self, SwigPyIterator x) -> ptrdiff_t\n"
		"  __sub__(self, ptrdiff_t n) -> SwigPyIterator\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PrintableCommon", _wrap_new_PrintableCommon, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  PrintableCommon()\n"
		"  PrintableCommon(PrintableCommon other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_PrintableCommon", (PyCFunction)_wrap_delete_PrintableCommon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  PrintableCommon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"PrintableCommon_swigregister", PrintableCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"SharedObject_class_name", (PyCFunction)_wrap_SharedObject_class_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  class_name(self) -> str\n"
		"\n"
		"Get class name.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_au\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L132\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L99-L101\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject_disp", _wrap_SharedObject_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print a description of the object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L135\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L103-L109\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject_str", _wrap_SharedObject_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L138\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L138-L142\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject_print_ptr", (PyCFunction)_wrap_SharedObject_print_ptr, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  print_ptr(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject_is_null", (PyCFunction)_wrap_SharedObject_is_null, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_null(self) -> bool\n"
		"\n"
		"Is a null pointer?\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L150\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L73-L75\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject___hash__", (PyCFunction)_wrap_SharedObject___hash__, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  __hash__(self) -> int\n"
		"\n"
		"Returns a number that is unique for a given Node.\n"
		"\n"
		"If the Object does not point to any node, \"0\" is returned.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_av\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L157\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L129-L131\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_SharedObject", _wrap_new_SharedObject, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  SharedObject()\n"
		"  SharedObject(SharedObject other)\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L93\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L33-L35\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  SharedObject(SharedObject other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  SharedObject()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L93\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L33-L35\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_SharedObject", (PyCFunction)_wrap_delete_SharedObject, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  SharedObject(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L42-L44\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SharedObject_swigregister", SharedObject_swigregister, METH_VARARGS, NULL},
	 { (char *)"WeakRef_shared", (PyCFunction)_wrap_WeakRef_shared, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  shared(self) -> SharedObject\n"
		"\n"
		"Get a shared (owning) reference.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_b0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L198\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L141-L147\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"WeakRef_alive", (PyCFunction)_wrap_WeakRef_alive, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  alive(self) -> bool\n"
		"\n"
		"Check if alive.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_b1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L203\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L137-L139\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_WeakRef", _wrap_new_WeakRef, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  WeakRef(int dummy)\n"
		"  WeakRef(WeakRef other)\n"
		"  WeakRef(SharedObject shared)\n"
		"\n"
		"Construct from a shared object (also implicit type conversion)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_az\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L193\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L157-L159\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  WeakRef(WeakRef other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  WeakRef(int dummy)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ay\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L188\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L133-L135\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  WeakRef(SharedObject shared)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct from a shared object (also implicit type conversion)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_az\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L193\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L157-L159\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_WeakRef", (PyCFunction)_wrap_delete_WeakRef, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  WeakRef(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"WeakRef_swigregister", WeakRef_swigregister, METH_VARARGS, NULL},
	 { (char *)"complement", _wrap_complement, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  complement([int] v, int size) -> [int]\n"
		"\n"
		"Returns the list of all i in [0, size[ not found in supplied \n"
		"list.\n"
		"\n"
		"The supplied vector may contain duplicates and may be non-monotonous \n"
		"The \n"
		"supplied vector will be checked for bounds The result vector is \n"
		"guaranteed \n"
		"to be monotonously increasing\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1lf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.cpp#L136-L152\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"lookupvector", _wrap_lookupvector, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  lookupvector([int] v) -> [int]\n"
		"  lookupvector([int] v, int size) -> [int]\n"
		"\n"
		"Returns a vector for quickly looking up entries of supplied \n"
		"list.\n"
		"\n"
		"lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v \n"
		"contains\n"
		" i\n"
		"\n"
		"Duplicates are treated by looking up last occurrence\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1lg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L154\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.cpp#L154-L163\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  lookupvector([int] v)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  lookupvector([int] v, int size)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Returns a vector for quickly looking up entries of supplied \n"
		"list.\n"
		"\n"
		"lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v \n"
		"contains\n"
		" i\n"
		"\n"
		"Duplicates are treated by looking up last occurrence\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1lg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L154\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.cpp#L154-L163\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"temporary_file", _wrap_temporary_file, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  temporary_file(str prefix, str suffix) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"normalized_setup", _wrap_normalized_setup, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  normalized_setup()\n"
		"  normalized_setup(std::istream & stream)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"normalized_out", (PyCFunction)_wrap_normalized_out, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  normalized_out(float val)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"normalized_in", _wrap_normalized_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  normalized_in(std::istream & stream, double & ret) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenericType_serialize", _wrap_GenericType_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_17r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.hpp#L249\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.cpp#L737-L740\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenericType_deserialize", (PyCFunction)_wrap_GenericType_deserialize, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(casadi::DeserializingStream & s) -> GenericType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GenericType", _wrap_new_GenericType, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  GenericType()\n"
		"  GenericType(GenericType other)\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.hpp#L85\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.cpp#L249-L250\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  GenericType(GenericType other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  GenericType()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.hpp#L85\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_type.cpp#L249-L250\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenericType", (PyCFunction)_wrap_delete_GenericType, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenericType(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenericType_swigregister", GenericType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SparsityInterfaceCommon", _wrap_new_SparsityInterfaceCommon, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  SparsityInterfaceCommon()\n"
		"  SparsityInterfaceCommon(SparsityInterfaceCommon other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_SparsityInterfaceCommon", (PyCFunction)_wrap_delete_SparsityInterfaceCommon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  SparsityInterfaceCommon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SparsityInterfaceCommon_swigregister", SparsityInterfaceCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"Sparsity_scalar", _wrap_Sparsity_scalar, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  scalar(bool dense_scalar) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_dense", _wrap_Sparsity_dense, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  dense(int nrow, int ncol) -> Sparsity\n"
		"  dense((int,int) rc) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_unit", _wrap_Sparsity_unit, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  unit(int n, int el) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_upper", (PyCFunction)_wrap_Sparsity_upper, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  upper(int n) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_lower", (PyCFunction)_wrap_Sparsity_lower, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  lower(int n) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_diag", _wrap_Sparsity_diag, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  diag(int nrow) -> Sparsity\n"
		"  diag((int,int) rc) -> Sparsity\n"
		"  diag(int nrow, int ncol) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_band", _wrap_Sparsity_band, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  band(int n, int p) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_banded", _wrap_Sparsity_banded, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  banded(int n, int p) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_rowcol", _wrap_Sparsity_rowcol, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rowcol([int] row, [int] col, int nrow, int ncol) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_triplet", _wrap_Sparsity_triplet, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  triplet(int nrow, int ncol, [int] row, [int] col) -> Sparsity\n"
		"  triplet(int nrow, int ncol, [int] row, [int] col, bool invert_mapping) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_nonzeros", _wrap_Sparsity_nonzeros, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  nonzeros(int nrow, int ncol, [int] nz, bool ind1) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_compressed", _wrap_Sparsity_compressed, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  compressed([int] v, bool order_rows) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_permutation", _wrap_Sparsity_permutation, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  permutation([int] p, bool invert) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_permutation_vector", _wrap_Sparsity_permutation_vector, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  permutation_vector(self, bool invert) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_diag", (PyCFunction)_wrap_Sparsity_get_diag, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_diag(self) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_compress", (PyCFunction)_wrap_Sparsity_compress, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  compress(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_equal", _wrap_Sparsity_is_equal, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_equal(self, Sparsity y) -> bool\n"
		"  is_equal(self, int nrow, int ncol, [int] colind, [int] row) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity___eq__", _wrap_Sparsity___eq__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __eq__(self, Sparsity y) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity___ne__", _wrap_Sparsity___ne__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __ne__(self, Sparsity y) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_stacked", _wrap_Sparsity_is_stacked, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_stacked(self, Sparsity y, int n) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_size1", (PyCFunction)_wrap_Sparsity_size1, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  size1(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_rows", (PyCFunction)_wrap_Sparsity_rows, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rows(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_size2", (PyCFunction)_wrap_Sparsity_size2, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  size2(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_columns", (PyCFunction)_wrap_Sparsity_columns, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  columns(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_numel", (PyCFunction)_wrap_Sparsity_numel, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  numel(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_density", (PyCFunction)_wrap_Sparsity_density, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  density(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_empty", _wrap_Sparsity_is_empty, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_empty(self, bool both) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_nnz", (PyCFunction)_wrap_Sparsity_nnz, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  nnz(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_nnz_upper", _wrap_Sparsity_nnz_upper, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_upper(self, bool strictly) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_nnz_lower", _wrap_Sparsity_nnz_lower, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_lower(self, bool strictly) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_nnz_diag", (PyCFunction)_wrap_Sparsity_nnz_diag, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_diag(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_bw_upper", (PyCFunction)_wrap_Sparsity_bw_upper, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  bw_upper(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_bw_lower", (PyCFunction)_wrap_Sparsity_bw_lower, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  bw_lower(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_size", _wrap_Sparsity_size, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  size(self) -> (int,int)\n"
		"  size(self, int axis) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_info", (PyCFunction)_wrap_Sparsity_info, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_to_file", _wrap_Sparsity_to_file, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  to_file(self, str filename, str format_hint)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_from_file", _wrap_Sparsity_from_file, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  from_file(str filename, str format_hint) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_serialize", _wrap_Sparsity_serialize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self) -> str\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_deserialize", _wrap_Sparsity_deserialize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(std::istream & stream) -> Sparsity\n"
		"  deserialize(casadi::DeserializingStream & s) -> Sparsity\n"
		"  deserialize(str s) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_colind", _wrap_Sparsity_colind, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self) -> [int]\n"
		"  colind(self, int cc) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_row", _wrap_Sparsity_row, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  row(self) -> [int]\n"
		"  row(self, int el) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_col", (PyCFunction)_wrap_Sparsity_get_col, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_col(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_resize", _wrap_Sparsity_resize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  resize(self, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_add_nz", _wrap_Sparsity_add_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  add_nz(self, int rr, int cc) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_has_nz", _wrap_Sparsity_has_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_nz(self, int rr, int cc) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_nz", _wrap_Sparsity_get_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self) -> [int]\n"
		"  get_nz(self, int rr, int cc) -> int\n"
		"  get_nz(self, [int] rr, [int] cc) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_lower", (PyCFunction)_wrap_Sparsity_get_lower, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_lower(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_upper", (PyCFunction)_wrap_Sparsity_get_upper, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_upper(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_ccs", (PyCFunction)_wrap_Sparsity_get_ccs, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_ccs(self) -> ([int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_crs", (PyCFunction)_wrap_Sparsity_get_crs, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_crs(self) -> ([int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_get_triplet", (PyCFunction)_wrap_Sparsity_get_triplet, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_triplet(self) -> ([int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_sub", _wrap_Sparsity_sub, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  sub(self, [int] rr, Sparsity sp, bool ind1) -> (Sparsity , [int] OUTPUT)\n"
		"  sub(self, [int] rr, [int] cc, bool ind1) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_transpose", _wrap_Sparsity_transpose, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  transpose(self, bool invert_mapping) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_transpose", _wrap_Sparsity_is_transpose, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_transpose(self, Sparsity y) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_reshape", _wrap_Sparsity_is_reshape, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_reshape(self, Sparsity y) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_combine", _wrap_Sparsity_combine, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  combine(self, Sparsity y, bool f0x_is_zero, bool function0_is_zero) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_unite", _wrap_Sparsity_unite, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  unite(self, Sparsity y) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity___add__", _wrap_Sparsity___add__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __add__(self, Sparsity b) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_intersect", _wrap_Sparsity_intersect, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  intersect(self, Sparsity y) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity___mul__", _wrap_Sparsity___mul__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __mul__(self, Sparsity b) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_subset", _wrap_Sparsity_is_subset, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_subset(self, Sparsity rhs) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_sparsity_cast_mod", _wrap_Sparsity_sparsity_cast_mod, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_cast_mod(self, Sparsity X, Sparsity Y) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_pattern_inverse", (PyCFunction)_wrap_Sparsity_pattern_inverse, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  pattern_inverse(self) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_enlarge", _wrap_Sparsity_enlarge, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_enlargeRows", _wrap_Sparsity_enlargeRows, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  enlargeRows(self, int nrow, [int] rr, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_enlargeColumns", _wrap_Sparsity_enlargeColumns, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  enlargeColumns(self, int ncol, [int] cc, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_makeDense", (PyCFunction)_wrap_Sparsity_makeDense, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  makeDense(self) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_erase", _wrap_Sparsity_erase, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1) -> [int]\n"
		"  erase(self, [int] rr, [int] cc, bool ind1) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_append", _wrap_Sparsity_append, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  append(self, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_appendColumns", _wrap_Sparsity_appendColumns, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  appendColumns(self, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_scalar", _wrap_Sparsity_is_scalar, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_scalar(self, bool scalar_and_dense) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_dense", (PyCFunction)_wrap_Sparsity_is_dense, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_dense(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_row", (PyCFunction)_wrap_Sparsity_is_row, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_row(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_column", (PyCFunction)_wrap_Sparsity_is_column, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_column(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_vector", (PyCFunction)_wrap_Sparsity_is_vector, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_vector(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_diag", (PyCFunction)_wrap_Sparsity_is_diag, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_diag(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_square", (PyCFunction)_wrap_Sparsity_is_square, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_square(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_symmetric", (PyCFunction)_wrap_Sparsity_is_symmetric, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_symmetric(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_triu", _wrap_Sparsity_is_triu, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_triu(self, bool strictly) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_tril", _wrap_Sparsity_is_tril, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_tril(self, bool strictly) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_singular", (PyCFunction)_wrap_Sparsity_is_singular, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_singular(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_permutation", (PyCFunction)_wrap_Sparsity_is_permutation, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_permutation(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_selection", _wrap_Sparsity_is_selection, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_selection(self, bool allow_empty) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_orthonormal", _wrap_Sparsity_is_orthonormal, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_orthonormal(self, bool allow_empty) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_orthonormal_rows", _wrap_Sparsity_is_orthonormal_rows, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_orthonormal_rows(self, bool allow_empty) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_is_orthonormal_columns", _wrap_Sparsity_is_orthonormal_columns, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_orthonormal_columns(self, bool allow_empty) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_rowsSequential", _wrap_Sparsity_rowsSequential, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rowsSequential(self, bool strictly) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_removeDuplicates", _wrap_Sparsity_removeDuplicates, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  removeDuplicates(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_etree", _wrap_Sparsity_etree, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  etree(self, bool ata) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_ldl", _wrap_Sparsity_ldl, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  ldl(self, bool amd) -> (Sparsity , [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_qr_sparse", _wrap_Sparsity_qr_sparse, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  qr_sparse(self, bool amd) -> (Sparsity OUTPUT, Sparsity OUTPUT, [int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_dfs", _wrap_Sparsity_dfs, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  dfs(self, int j, int top, [int] pinv) -> (int , [int] INOUT, [int] INOUT, [bool] INOUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_scc", (PyCFunction)_wrap_Sparsity_scc, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  scc(self) -> (int , [int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_btf", (PyCFunction)_wrap_Sparsity_btf, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  btf(self) -> (int , [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_amd", (PyCFunction)_wrap_Sparsity_amd, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  amd(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_find", _wrap_Sparsity_find, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  find(self, bool ind1) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_uni_coloring", _wrap_Sparsity_uni_coloring, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  uni_coloring(self, Sparsity AT, int cutoff) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_star_coloring", _wrap_Sparsity_star_coloring, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  star_coloring(self, int ordering, int cutoff) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_star_coloring2", _wrap_Sparsity_star_coloring2, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  star_coloring2(self, int ordering, int cutoff) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_largest_first", (PyCFunction)_wrap_Sparsity_largest_first, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  largest_first(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_pmult", _wrap_Sparsity_pmult, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  pmult(self, [int] p, bool permute_rows, bool permute_columns, bool invert_permutation) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_dim", _wrap_Sparsity_dim, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  dim(self, bool with_nz) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_postfix_dim", (PyCFunction)_wrap_Sparsity_postfix_dim, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  postfix_dim(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_repr_el", _wrap_Sparsity_repr_el, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  repr_el(self, int k) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_spy", (PyCFunction)_wrap_Sparsity_spy, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  spy(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_spy_matlab", _wrap_Sparsity_spy_matlab, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  spy_matlab(self, str mfile)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_export_code", _wrap_Sparsity_export_code, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, dict options)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_type_name", (PyCFunction)_wrap_Sparsity_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_hash", (PyCFunction)_wrap_Sparsity_hash, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  hash(self) -> std::size_t\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_test_cast", (PyCFunction)_wrap_Sparsity_test_cast, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  test_cast(casadi::SharedObjectInternal const * ptr) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_kkt", _wrap_Sparsity_kkt, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  kkt(Sparsity H, Sparsity J, bool with_x_diag, bool with_lam_g_diag) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Sparsity", _wrap_new_Sparsity, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Sparsity(int dummy)\n"
		"  Sparsity((int,int) rc)\n"
		"  Sparsity(Sparsity other)\n"
		"  Sparsity(int nrow, int ncol)\n"
		"  Sparsity(int nrow, int ncol, [int] colind, [int] row, bool order_rows)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Sparsity", (PyCFunction)_wrap_delete_Sparsity, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Sparsity(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Sparsity_swigregister", Sparsity_swigregister, METH_VARARGS, NULL},
	 { (char *)"hash_sparsity", _wrap_hash_sparsity, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  hash_sparsity(int nrow, int ncol, casadi_int const * colind, casadi_int const * row) -> std::size_t\n"
		"  hash_sparsity(int nrow, int ncol, [int] colind, [int] row) -> std::size_t\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_start_get", (PyCFunction)_wrap_Slice_start_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Slice_start_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_stop_get", (PyCFunction)_wrap_Slice_stop_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Slice_stop_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_step_get", (PyCFunction)_wrap_Slice_step_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Slice_step_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_all", _wrap_Slice_all, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  all(self) -> [int]\n"
		"  all(self, int len, bool ind1) -> [int]\n"
		"  all(self, Slice outer, int len) -> [int]\n"
		"\n"
		"Get a vector of indices.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L72\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L100-L102\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  all(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a vector of indices.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L69\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L90-L98\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  all(self, int len, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a vector of indices.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L72\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L100-L102\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  all(self, Slice outer, int len)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a vector of indices (nested slice)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L75\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L129-L137\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_size", (PyCFunction)_wrap_Slice_size, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size(self) -> size_t\n"
		"\n"
		"Get number of elements.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L78\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L104-L109\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_is_empty", (PyCFunction)_wrap_Slice_is_empty, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_empty(self) -> bool\n"
		"\n"
		"Check if slice is empty.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L81\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L111-L113\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_is_scalar", _wrap_Slice_is_scalar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_scalar(self, int len) -> bool\n"
		"\n"
		"Is the slice a scalar.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L84\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L139-L144\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_scalar", _wrap_Slice_scalar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  scalar(self, int len) -> int\n"
		"\n"
		"Get scalar (if is_scalar)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L87\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L146-L150\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice___eq__", _wrap_Slice___eq__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __eq__(self, Slice other) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice___ne__", _wrap_Slice___ne__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __ne__(self, Slice other) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_apply", _wrap_Slice_apply, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  apply(self, int len, bool ind1) -> Slice\n"
		"\n"
		"Apply concrete length.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L98\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L66-L88\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice___sub__", _wrap_Slice___sub__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __sub__(self, int i) -> Slice\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice___mul__", _wrap_Slice___mul__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __mul__(self, int i) -> Slice\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_type_name", (PyCFunction)_wrap_Slice_type_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type_name(self) -> str\n"
		"\n"
		"Get name of the class.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L107\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L107-L107\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_disp", _wrap_Slice_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print a description of the object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L110\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L115-L127\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_str", _wrap_Slice_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L113\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L113-L117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_info", (PyCFunction)_wrap_Slice_info, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"Obtain information\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L120\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L120-L122\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_serialize", _wrap_Slice_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_14\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L127\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L292-L296\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_deserialize", (PyCFunction)_wrap_Slice_deserialize, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(casadi::DeserializingStream & s) -> Slice\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Slice", _wrap_new_Slice, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Slice()\n"
		"  Slice(int i, bool ind1)\n"
		"  Slice(Slice other)\n"
		"  Slice(int start, int stop, int step)\n"
		"  Slice(int start, int stop, int step)\n"
		"  Slice(int start, int stop, int step)\n"
		"  Slice(int start, int stop, int step)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Slice(Slice other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Slice()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor - all elements.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L57\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L32-L33\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Slice(int i, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"A single element (explicit to avoid ambiguity with IM overload.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L60\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L35-L42\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Slice(int start, int stop, int step)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"A slice.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L63\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L44-L45\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Slice(int start, int stop, int step)\n"
		"  Slice(int start, int stop, int step)\n"
		"  Slice(int start, int stop, int step)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Slice", (PyCFunction)_wrap_delete_Slice, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Slice(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Slice_swigregister", Slice_swigregister, METH_VARARGS, NULL},
	 { (char *)"to_slice", _wrap_to_slice, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  to_slice([int] v, bool ind1) -> Slice\n"
		"\n"
		"Construct from an index vector (requires is_slice(v) to be true)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L152\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L152-L168\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"to_slice2", (PyCFunction)_wrap_to_slice2, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  to_slice2([int] v) -> std::pair< casadi::Slice,casadi::Slice >\n"
		"\n"
		"Construct nested slices from an index vector (requires \n"
		"is_slice2(v) to\n"
		" be true)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L255\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L255-L289\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"is_slice", _wrap_is_slice, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_slice([int] v, bool ind1) -> bool\n"
		"\n"
		"Check if an index vector can be represented more efficiently as \n"
		"a \n"
		"slice.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L170\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L170-L200\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"is_slice2", (PyCFunction)_wrap_is_slice2, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_slice2([int] v) -> bool\n"
		"\n"
		"Check if an index vector can be represented more efficiently as \n"
		"two \n"
		"nested slices.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.hpp#L202\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/slice.cpp#L202-L253\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GenericMatrixCommon", _wrap_new_GenericMatrixCommon, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenericMatrixCommon()\n"
		"  GenericMatrixCommon(GenericMatrixCommon other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenericMatrixCommon", (PyCFunction)_wrap_delete_GenericMatrixCommon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenericMatrixCommon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenericMatrixCommon_swigregister", GenericMatrixCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"index_interp1d", _wrap_index_interp1d, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  index_interp1d([float] x, float xq, bool equidistant) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_nnz", (PyCFunction)_wrap_GenDM_nnz, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz(self) -> int\n"
		"\n"
		"Get the number of (structural) non-zero elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1an\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L84\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1119-L1121\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_nnz_lower", (PyCFunction)_wrap_GenDM_nnz_lower, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_lower(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the lower triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ao\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L89\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1124-L1126\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_nnz_upper", (PyCFunction)_wrap_GenDM_nnz_upper, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_upper(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the upper triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ap\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L94\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1129-L1131\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_nnz_diag", (PyCFunction)_wrap_GenDM_nnz_diag, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_diag(self) -> int\n"
		"\n"
		"Get get the number of non-zeros on the diagonal.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1134-L1136\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_numel", (PyCFunction)_wrap_GenDM_numel, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel(self) -> int\n"
		"\n"
		"Get the number of elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ar\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L104\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1139-L1141\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_size1", (PyCFunction)_wrap_GenDM_size1, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size1(self) -> int\n"
		"\n"
		"Get the first dimension (i.e. number of rows)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1as\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L109\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1144-L1146\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_rows", (PyCFunction)_wrap_GenDM_rows, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rows(self) -> int\n"
		"\n"
		"Get the number of rows, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1at\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114-L114\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_size2", (PyCFunction)_wrap_GenDM_size2, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size2(self) -> int\n"
		"\n"
		"Get the second dimension (i.e. number of columns)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1au\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L119\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1149-L1151\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_columns", (PyCFunction)_wrap_GenDM_columns, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  columns(self) -> int\n"
		"\n"
		"Get the number of columns, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1av\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124-L124\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_dim", _wrap_GenDM_dim, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dim(self, bool with_nz) -> str\n"
		"\n"
		"Get string representation of dimensions.\n"
		"\n"
		"The representation is e.g. \"4x5\" or \"4x5,10nz\"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L131\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1164-L1166\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_size", _wrap_GenDM_size, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size(self) -> (int,int)\n"
		"  size(self, int axis) -> int\n"
		"\n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self, int axis)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the size along a particular dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ay\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L141\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1159-L1161\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_empty", _wrap_GenDM_is_empty, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_empty(self, bool both) -> bool\n"
		"\n"
		"Check if the sparsity is empty, i.e. if one of the dimensions is\n"
		" zero.\n"
		"\n"
		"(or optionally both dimensions)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1az\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148-L148\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_dense", (PyCFunction)_wrap_GenDM_is_dense, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_dense(self) -> bool\n"
		"\n"
		"Check if the matrix expression is dense.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153-L153\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_scalar", _wrap_GenDM_is_scalar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_scalar(self, bool scalar_and_dense) -> bool\n"
		"\n"
		"Check if the matrix expression is scalar.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L158\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1169-L1171\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_square", (PyCFunction)_wrap_GenDM_is_square, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_square(self) -> bool\n"
		"\n"
		"Check if the matrix expression is square.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163-L163\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_vector", (PyCFunction)_wrap_GenDM_is_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_vector(self) -> bool\n"
		"\n"
		"Check if the matrix is a row or column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168-L168\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_row", (PyCFunction)_wrap_GenDM_is_row, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_row(self) -> bool\n"
		"\n"
		"Check if the matrix is a row vector (i.e.  size1()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173-L173\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_column", (PyCFunction)_wrap_GenDM_is_column, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_column(self) -> bool\n"
		"\n"
		"Check if the matrix is a column vector (i.e.  size2()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178-L178\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_triu", (PyCFunction)_wrap_GenDM_is_triu, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_triu(self) -> bool\n"
		"\n"
		"Check if the matrix is upper triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183-L183\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_is_tril", (PyCFunction)_wrap_GenDM_is_tril, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_tril(self) -> bool\n"
		"\n"
		"Check if the matrix is lower triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188-L188\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_row", _wrap_GenDM_row, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  row(self) -> [int]\n"
		"  row(self, int el) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self, int el)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200-L200\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_colind", _wrap_GenDM_colind, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  colind(self) -> [int]\n"
		"  colind(self, int col) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self, int col)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201-L201\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_sparsity", (PyCFunction)_wrap_GenDM_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1114-L1116\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_sym", _wrap_GenDM_sym, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol) -> DM\n"
		"  sym(str name, (int,int) rc) -> DM\n"
		"  sym(str name, Sparsity sp) -> DM\n"
		"  sym(str name, Sparsity sp, int p) -> [DM]\n"
		"  sym(str name, int nrow, int ncol, int p) -> [DM]\n"
		"  sym(str name, Sparsity sp, int p, int r) -> [[DM]]\n"
		"  sym(str name, int nrow, int ncol, int p, int r) -> [[DM]]\n"
		"\n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, (int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a symbolic primitive with given dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1db\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034-L1036\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with nrow-by-ncol symbolic \n"
		"primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1de\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055-L1058\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create an nrow-by-ncol symbolic primitive.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1da\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027-L1029\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with with matrices.\n"
		"\n"
		"with symbolic primitives of given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1050\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1176-L1186\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create symbolic primitive with a given sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041-L1043\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p.\n"
		"\n"
		"with nrow-by-ncol symbolic primitives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074-L1076\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_zeros", _wrap_GenDM_zeros, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol) -> DM\n"
		"  zeros((int,int) rc) -> DM\n"
		"  zeros(Sparsity sp) -> DM\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083-L1085\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087-L1089\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_ones", _wrap_GenDM_ones, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol) -> DM\n"
		"  ones((int,int) rc) -> DM\n"
		"  ones(Sparsity sp) -> DM\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096-L1098\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100-L1102\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GenDM", _wrap_new_GenDM, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenDM()\n"
		"  GenDM(GenDM other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenDM", (PyCFunction)_wrap_delete_GenDM, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenDM(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenDM_swigregister", GenDM_swigregister, METH_VARARGS, NULL},
	 { (char *)"GenSX_nnz", (PyCFunction)_wrap_GenSX_nnz, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz(self) -> int\n"
		"\n"
		"Get the number of (structural) non-zero elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1an\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L84\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1119-L1121\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_nnz_lower", (PyCFunction)_wrap_GenSX_nnz_lower, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_lower(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the lower triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ao\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L89\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1124-L1126\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_nnz_upper", (PyCFunction)_wrap_GenSX_nnz_upper, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_upper(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the upper triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ap\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L94\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1129-L1131\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_nnz_diag", (PyCFunction)_wrap_GenSX_nnz_diag, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_diag(self) -> int\n"
		"\n"
		"Get get the number of non-zeros on the diagonal.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1134-L1136\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_numel", (PyCFunction)_wrap_GenSX_numel, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel(self) -> int\n"
		"\n"
		"Get the number of elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ar\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L104\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1139-L1141\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_size1", (PyCFunction)_wrap_GenSX_size1, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size1(self) -> int\n"
		"\n"
		"Get the first dimension (i.e. number of rows)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1as\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L109\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1144-L1146\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_rows", (PyCFunction)_wrap_GenSX_rows, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rows(self) -> int\n"
		"\n"
		"Get the number of rows, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1at\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114-L114\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_size2", (PyCFunction)_wrap_GenSX_size2, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size2(self) -> int\n"
		"\n"
		"Get the second dimension (i.e. number of columns)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1au\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L119\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1149-L1151\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_columns", (PyCFunction)_wrap_GenSX_columns, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  columns(self) -> int\n"
		"\n"
		"Get the number of columns, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1av\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124-L124\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_dim", _wrap_GenSX_dim, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dim(self, bool with_nz) -> str\n"
		"\n"
		"Get string representation of dimensions.\n"
		"\n"
		"The representation is e.g. \"4x5\" or \"4x5,10nz\"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L131\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1164-L1166\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_size", _wrap_GenSX_size, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size(self) -> (int,int)\n"
		"  size(self, int axis) -> int\n"
		"\n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self, int axis)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the size along a particular dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ay\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L141\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1159-L1161\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_empty", _wrap_GenSX_is_empty, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_empty(self, bool both) -> bool\n"
		"\n"
		"Check if the sparsity is empty, i.e. if one of the dimensions is\n"
		" zero.\n"
		"\n"
		"(or optionally both dimensions)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1az\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148-L148\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_dense", (PyCFunction)_wrap_GenSX_is_dense, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_dense(self) -> bool\n"
		"\n"
		"Check if the matrix expression is dense.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153-L153\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_scalar", _wrap_GenSX_is_scalar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_scalar(self, bool scalar_and_dense) -> bool\n"
		"\n"
		"Check if the matrix expression is scalar.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L158\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1169-L1171\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_square", (PyCFunction)_wrap_GenSX_is_square, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_square(self) -> bool\n"
		"\n"
		"Check if the matrix expression is square.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163-L163\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_vector", (PyCFunction)_wrap_GenSX_is_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_vector(self) -> bool\n"
		"\n"
		"Check if the matrix is a row or column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168-L168\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_row", (PyCFunction)_wrap_GenSX_is_row, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_row(self) -> bool\n"
		"\n"
		"Check if the matrix is a row vector (i.e.  size1()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173-L173\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_column", (PyCFunction)_wrap_GenSX_is_column, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_column(self) -> bool\n"
		"\n"
		"Check if the matrix is a column vector (i.e.  size2()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178-L178\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_triu", (PyCFunction)_wrap_GenSX_is_triu, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_triu(self) -> bool\n"
		"\n"
		"Check if the matrix is upper triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183-L183\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_is_tril", (PyCFunction)_wrap_GenSX_is_tril, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_tril(self) -> bool\n"
		"\n"
		"Check if the matrix is lower triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188-L188\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_row", _wrap_GenSX_row, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  row(self) -> [int]\n"
		"  row(self, int el) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self, int el)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200-L200\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_colind", _wrap_GenSX_colind, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  colind(self) -> [int]\n"
		"  colind(self, int col) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self, int col)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201-L201\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_sparsity", (PyCFunction)_wrap_GenSX_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1114-L1116\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_sym", _wrap_GenSX_sym, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol) -> SX\n"
		"  sym(str name, (int,int) rc) -> SX\n"
		"  sym(str name, Sparsity sp) -> SX\n"
		"  sym(str name, Sparsity sp, int p) -> [SX]\n"
		"  sym(str name, int nrow, int ncol, int p) -> [SX]\n"
		"  sym(str name, Sparsity sp, int p, int r) -> [[SX]]\n"
		"  sym(str name, int nrow, int ncol, int p, int r) -> [[SX]]\n"
		"\n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, (int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a symbolic primitive with given dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1db\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034-L1036\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with nrow-by-ncol symbolic \n"
		"primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1de\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055-L1058\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create an nrow-by-ncol symbolic primitive.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1da\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027-L1029\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with with matrices.\n"
		"\n"
		"with symbolic primitives of given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1050\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1176-L1186\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create symbolic primitive with a given sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041-L1043\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p.\n"
		"\n"
		"with nrow-by-ncol symbolic primitives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074-L1076\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_zeros", _wrap_GenSX_zeros, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol) -> SX\n"
		"  zeros((int,int) rc) -> SX\n"
		"  zeros(Sparsity sp) -> SX\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083-L1085\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087-L1089\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_ones", _wrap_GenSX_ones, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol) -> SX\n"
		"  ones((int,int) rc) -> SX\n"
		"  ones(Sparsity sp) -> SX\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096-L1098\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100-L1102\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GenSX", _wrap_new_GenSX, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenSX()\n"
		"  GenSX(GenSX other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenSX", (PyCFunction)_wrap_delete_GenSX, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenSX(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenSX_swigregister", GenSX_swigregister, METH_VARARGS, NULL},
	 { (char *)"GenMX_nnz", (PyCFunction)_wrap_GenMX_nnz, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz(self) -> int\n"
		"\n"
		"Get the number of (structural) non-zero elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1an\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L84\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1119-L1121\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_nnz_lower", (PyCFunction)_wrap_GenMX_nnz_lower, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_lower(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the lower triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ao\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L89\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1124-L1126\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_nnz_upper", (PyCFunction)_wrap_GenMX_nnz_upper, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_upper(self) -> int\n"
		"\n"
		"Get the number of non-zeros in the upper triangular half.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ap\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L94\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1129-L1131\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_nnz_diag", (PyCFunction)_wrap_GenMX_nnz_diag, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_diag(self) -> int\n"
		"\n"
		"Get get the number of non-zeros on the diagonal.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1134-L1136\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_numel", (PyCFunction)_wrap_GenMX_numel, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel(self) -> int\n"
		"\n"
		"Get the number of elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ar\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L104\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1139-L1141\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_size1", (PyCFunction)_wrap_GenMX_size1, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size1(self) -> int\n"
		"\n"
		"Get the first dimension (i.e. number of rows)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1as\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L109\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1144-L1146\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_rows", (PyCFunction)_wrap_GenMX_rows, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rows(self) -> int\n"
		"\n"
		"Get the number of rows, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1at\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L114-L114\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_size2", (PyCFunction)_wrap_GenMX_size2, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size2(self) -> int\n"
		"\n"
		"Get the second dimension (i.e. number of columns)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1au\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L119\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1149-L1151\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_columns", (PyCFunction)_wrap_GenMX_columns, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  columns(self) -> int\n"
		"\n"
		"Get the number of columns, Octave-style syntax.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1av\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L124-L124\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_dim", _wrap_GenMX_dim, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dim(self, bool with_nz) -> str\n"
		"\n"
		"Get string representation of dimensions.\n"
		"\n"
		"The representation is e.g. \"4x5\" or \"4x5,10nz\"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1aw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L131\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1164-L1166\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_size", _wrap_GenMX_size, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size(self) -> (int,int)\n"
		"  size(self, int axis) -> int\n"
		"\n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self, int axis)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the size along a particular dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ay\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L141\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1159-L1161\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the shape.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ax\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_empty", _wrap_GenMX_is_empty, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_empty(self, bool both) -> bool\n"
		"\n"
		"Check if the sparsity is empty, i.e. if one of the dimensions is\n"
		" zero.\n"
		"\n"
		"(or optionally both dimensions)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1az\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L148-L148\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_dense", (PyCFunction)_wrap_GenMX_is_dense, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_dense(self) -> bool\n"
		"\n"
		"Check if the matrix expression is dense.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L153-L153\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_scalar", _wrap_GenMX_is_scalar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_scalar(self, bool scalar_and_dense) -> bool\n"
		"\n"
		"Check if the matrix expression is scalar.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L158\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1169-L1171\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_square", (PyCFunction)_wrap_GenMX_is_square, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_square(self) -> bool\n"
		"\n"
		"Check if the matrix expression is square.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L163-L163\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_vector", (PyCFunction)_wrap_GenMX_is_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_vector(self) -> bool\n"
		"\n"
		"Check if the matrix is a row or column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L168-L168\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_row", (PyCFunction)_wrap_GenMX_is_row, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_row(self) -> bool\n"
		"\n"
		"Check if the matrix is a row vector (i.e.  size1()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L173-L173\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_column", (PyCFunction)_wrap_GenMX_is_column, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_column(self) -> bool\n"
		"\n"
		"Check if the matrix is a column vector (i.e.  size2()==1)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L178-L178\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_triu", (PyCFunction)_wrap_GenMX_is_triu, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_triu(self) -> bool\n"
		"\n"
		"Check if the matrix is upper triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L183-L183\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_is_tril", (PyCFunction)_wrap_GenMX_is_tril, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_tril(self) -> bool\n"
		"\n"
		"Check if the matrix is lower triangular.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L188-L188\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_row", _wrap_GenMX_row, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  row(self) -> [int]\n"
		"  row(self, int el) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L194-L194\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  row(self, int el)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L200-L200\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_colind", _wrap_GenMX_colind, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  colind(self) -> [int]\n"
		"  colind(self, int col) -> int\n"
		"\n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L195-L195\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  colind(self, int col)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the sparsity pattern. See the Sparsity class for details.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L201-L201\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_sparsity", (PyCFunction)_wrap_GenMX_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1114-L1116\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_sym", _wrap_GenMX_sym, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol) -> MX\n"
		"  sym(str name, (int,int) rc) -> MX\n"
		"  sym(str name, Sparsity sp) -> MX\n"
		"  sym(str name, Sparsity sp, int p) -> [MX]\n"
		"  sym(str name, int nrow, int ncol, int p) -> [MX]\n"
		"  sym(str name, Sparsity sp, int p, int r) -> [[MX]]\n"
		"  sym(str name, int nrow, int ncol, int p, int r) -> [[MX]]\n"
		"\n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, (int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a symbolic primitive with given dimensions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1db\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1034-L1036\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with nrow-by-ncol symbolic \n"
		"primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1de\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1055-L1058\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create an nrow-by-ncol symbolic primitive.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1da\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1027-L1029\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length p with with matrices.\n"
		"\n"
		"with symbolic primitives of given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1050\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1176-L1186\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create symbolic primitive with a given sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1041-L1043\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, Sparsity sp, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p with.\n"
		"\n"
		"symbolic primitives with given sparsity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1df\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1066\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1189-L1199\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sym(str name, int nrow, int ncol, int p, int r)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a vector of length r of vectors of length p.\n"
		"\n"
		"with nrow-by-ncol symbolic primitives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1074-L1076\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_zeros", _wrap_GenMX_zeros, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol) -> MX\n"
		"  zeros((int,int) rc) -> MX\n"
		"  zeros(Sparsity sp) -> MX\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1083-L1085\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1087-L1089\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  zeros(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries zero.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1dh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1086-L1086\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_ones", _wrap_GenMX_ones, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol) -> MX\n"
		"  ones((int,int) rc) -> MX\n"
		"  ones(Sparsity sp) -> MX\n"
		"\n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1096-L1098\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1100-L1102\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  ones(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a dense matrix or a matrix with specified sparsity with \n"
		"all \n"
		"entries one.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1di\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L1099-L1099\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GenMX", _wrap_new_GenMX, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenMX()\n"
		"  GenMX(GenMX other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenMX", (PyCFunction)_wrap_delete_GenMX, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenMX(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenMX_swigregister", GenMX_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GenericExpressionCommon", _wrap_new_GenericExpressionCommon, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenericExpressionCommon()\n"
		"  GenericExpressionCommon(GenericExpressionCommon other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GenericExpressionCommon", (PyCFunction)_wrap_delete_GenericExpressionCommon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GenericExpressionCommon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GenericExpressionCommon_swigregister", GenericExpressionCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MatrixCommon", _wrap_new_MatrixCommon, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  MatrixCommon()\n"
		"  MatrixCommon(MatrixCommon other)\n"
		"\n"
		"constructors\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18f  empty 0-by-0 matrix \n"
		"constructor\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L576-L577\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MatrixCommon()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"constructors\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18f  empty 0-by-0 matrix \n"
		"constructor\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L576-L577\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MatrixCommon(MatrixCommon other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_MatrixCommon", (PyCFunction)_wrap_delete_MatrixCommon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MatrixCommon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MatrixCommon_swigregister", MatrixCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"DM_has_nz", _wrap_DM_has_nz, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_nz(self, int rr, int cc) -> bool\n"
		"\n"
		"Returns true if the matrix has a non-zero at location rr, cc.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L219\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L65-L67\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM___bool__", (PyCFunction)_wrap_DM___bool__, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  __bool__(self) -> bool\n"
		"\n"
		"Returns the truth value of a  Matrix.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L222\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L70-L76\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_get", _wrap_DM_get, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Sparsity sp) -> DM\n"
		"  get(self, bool ind1, Slice rr) -> DM\n"
		"  get(self, bool ind1, IM rr) -> DM\n"
		"  get(self, bool ind1, Slice rr, Slice cc) -> DM\n"
		"  get(self, bool ind1, Slice rr, IM cc) -> DM\n"
		"  get(self, bool ind1, IM rr, Slice cc) -> DM\n"
		"  get(self, bool ind1, IM rr, IM cc) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set", _wrap_DM_set, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, DM m, bool ind1, Sparsity sp)\n"
		"  set(self, DM m, bool ind1, Slice rr)\n"
		"  set(self, DM m, bool ind1, IM rr)\n"
		"  set(self, DM m, bool ind1, Slice rr, Slice cc)\n"
		"  set(self, DM m, bool ind1, Slice rr, IM cc)\n"
		"  set(self, DM m, bool ind1, IM rr, Slice cc)\n"
		"  set(self, DM m, bool ind1, IM rr, IM cc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_get_nz", _wrap_DM_get_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, Slice k) -> DM\n"
		"  get_nz(self, bool ind1, IM k) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set_nz", _wrap_DM_set_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, DM m, bool ind1, Slice k)\n"
		"  set_nz(self, DM m, bool ind1, IM k)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM___pos__", (PyCFunction)_wrap_DM___pos__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __pos__(self) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM___neg__", (PyCFunction)_wrap_DM___neg__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __neg__(self) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_binary", _wrap_DM_binary, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  binary(int op, DM x, DM y) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_unary", _wrap_DM_unary, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  unary(int op, DM x) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_scalar_matrix", _wrap_DM_scalar_matrix, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  scalar_matrix(int op, DM x, DM y) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_matrix_scalar", _wrap_DM_matrix_scalar, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  matrix_scalar(int op, DM x, DM y) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_matrix_matrix", _wrap_DM_matrix_matrix, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  matrix_matrix(int op, DM x, DM y) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_printme", _wrap_DM_printme, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  printme(self, DM y) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set_max_depth", _wrap_DM_set_max_depth, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_max_depth(int eq_depth)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_get_max_depth", (PyCFunction)_wrap_DM_get_max_depth, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_max_depth() -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_get_input", (PyCFunction)_wrap_DM_get_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_input(Function f) -> [DM]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_get_free", (PyCFunction)_wrap_DM_get_free, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_free(Function f) -> [DM]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_type_name", (PyCFunction)_wrap_DM_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_print_split", (PyCFunction)_wrap_DM_print_split, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_split(self) -> ([str] OUTPUT, [str] OUTPUT)\n"
		"\n"
		"Get strings corresponding to the nonzeros and the \n"
		"interdependencies.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L873\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L696-L700\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_disp", _wrap_DM_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print a representation of the object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L877\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_str", _wrap_DM_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L880\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_print_scalar", (PyCFunction)_wrap_DM_print_scalar, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_scalar(self)\n"
		"\n"
		"Print scalar.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L883\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L609-L633\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_print_vector", _wrap_DM_print_vector, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_vector(self, bool truncate)\n"
		"\n"
		"Print vector-style.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L886\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L636-L638\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_print_dense", _wrap_DM_print_dense, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_dense(self, bool truncate)\n"
		"\n"
		"Print dense matrix-stype.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L889\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L686-L688\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_print_sparse", _wrap_DM_print_sparse, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_sparse(self, bool truncate)\n"
		"\n"
		"Print sparse matrix style.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L892\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L691-L693\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_clear", (PyCFunction)_wrap_DM_clear, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  clear(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_resize", _wrap_DM_resize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  resize(self, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_reserve", _wrap_DM_reserve, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reserve(self, int nnz)\n"
		"  reserve(self, int nnz, int ncol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_erase", _wrap_DM_erase, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L929\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase elements of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L937\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L929\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_remove", _wrap_DM_remove, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  remove(self, [int] rr, [int] cc)\n"
		"\n"
		"Remove columns and rows.\n"
		"\n"
		"Remove/delete rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L944\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_enlarge", _wrap_DM_enlarge, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Enlarge matrix.\n"
		"\n"
		"Make the matrix larger by inserting empty rows and columns, keeping \n"
		"the \n"
		"existing non-zeros\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19i\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L952\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_sparsity", (PyCFunction)_wrap_DM_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get an owning reference to the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L979\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_triplet", _wrap_DM_triplet, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  triplet([int] row, [int] col, DM d) -> DM\n"
		"  triplet([int] row, [int] col, DM d, (int,int) rc) -> DM\n"
		"  triplet([int] row, [int] col, DM d, int nrow, int ncol) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_inf", _wrap_DM_inf, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol) -> DM\n"
		"  inf((int,int) rc) -> DM\n"
		"  inf(Sparsity sp) -> DM\n"
		"\n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1004\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1004\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1005\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1003\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_nan", _wrap_DM_nan, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol) -> DM\n"
		"  nan((int,int) rc) -> DM\n"
		"  nan(Sparsity sp) -> DM\n"
		"\n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1013\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1013\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1014\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1012\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_eye", (PyCFunction)_wrap_DM_eye, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  eye(int n) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_element_hash", (PyCFunction)_wrap_DM_element_hash, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  element_hash(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_regular", (PyCFunction)_wrap_DM_is_regular, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_regular(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_smooth", (PyCFunction)_wrap_DM_is_smooth, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_smooth(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_leaf", (PyCFunction)_wrap_DM_is_leaf, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_leaf(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_commutative", (PyCFunction)_wrap_DM_is_commutative, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_commutative(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_symbolic", (PyCFunction)_wrap_DM_is_symbolic, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_symbolic(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_valid_input", (PyCFunction)_wrap_DM_is_valid_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_valid_input(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_has_duplicates", (PyCFunction)_wrap_DM_has_duplicates, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_duplicates(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_reset_input", (PyCFunction)_wrap_DM_reset_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  reset_input(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_constant", (PyCFunction)_wrap_DM_is_constant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_constant(self) -> bool\n"
		"\n"
		"Check if the matrix is constant (note that false negative \n"
		"answers are \n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19v\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1100\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_integer", (PyCFunction)_wrap_DM_is_integer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_integer(self) -> bool\n"
		"\n"
		"Check if the matrix is integer-valued.\n"
		"\n"
		"(note that false negative answers are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1107\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_zero", (PyCFunction)_wrap_DM_is_zero, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_zero(self) -> bool\n"
		"\n"
		"check if the matrix is 0 (note that false negative answers are \n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1112\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_one", (PyCFunction)_wrap_DM_is_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_one(self) -> bool\n"
		"\n"
		"check if the matrix is 1 (note that false negative answers are \n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_minus_one", (PyCFunction)_wrap_DM_is_minus_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_minus_one(self) -> bool\n"
		"\n"
		"check if the matrix is -1 (note that false negative answers are\n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1122\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_eye", (PyCFunction)_wrap_DM_is_eye, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_eye(self) -> bool\n"
		"\n"
		"check if the matrix is an identity matrix (note that false \n"
		"negative \n"
		"answers\n"
		"\n"
		"are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1129\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_op", (PyCFunction)_wrap_DM_op, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  op(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_is_op", _wrap_DM_is_op, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_op(self, int op) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_has_zeros", (PyCFunction)_wrap_DM_has_zeros, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_zeros(self) -> bool\n"
		"\n"
		"Check if the matrix has any zero entries which are not \n"
		"structural \n"
		"zeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1140\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_nonzeros", (PyCFunction)_wrap_DM_nonzeros, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nonzeros(self) -> [float]\n"
		"\n"
		"Get all nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1157\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_elements", (PyCFunction)_wrap_DM_elements, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  elements(self) -> [float]\n"
		"\n"
		"Get all elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1150\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM___float__", (PyCFunction)_wrap_DM___float__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __float__(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM___int__", (PyCFunction)_wrap_DM___int__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __int__(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_name", (PyCFunction)_wrap_DM_name, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  name(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_dep", _wrap_DM_dep, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  dep(self, int ch) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_n_dep", (PyCFunction)_wrap_DM_n_dep, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  n_dep(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set_precision", (PyCFunction)_wrap_DM_set_precision, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_precision(int precision)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set_width", (PyCFunction)_wrap_DM_set_width, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_width(int width)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_set_scientific", (PyCFunction)_wrap_DM_set_scientific, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_scientific(bool scientific)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_rng", (PyCFunction)_wrap_DM_rng, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rng(int seed)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_rand", _wrap_DM_rand, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rand(int nrow, int ncol) -> DM\n"
		"  rand((int,int) rc) -> DM\n"
		"  rand(Sparsity sp) -> DM\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a matrix with uniformly distributed random numbers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ab\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1212\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a matrix with uniformly distributed random numbers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ab\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1216\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_export_code", _wrap_DM_export_code, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, dict options)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_info", (PyCFunction)_wrap_DM_info, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_serialize", _wrap_DM_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self) -> str\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ae\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1249\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ah\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1264\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Serialize.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ae\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1249\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_deserialize", _wrap_DM_deserialize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(std::istream & stream) -> DM\n"
		"  deserialize(casadi::DeserializingStream & s) -> DM\n"
		"  deserialize(str s) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_to_file", _wrap_DM_to_file, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  to_file(self, str filename, str format)\n"
		"\n"
		"Export numerical matrix to file\n"
		"\n"
		"Supported formats:\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  *   - .mtx   Matrix Market (sparse)\n"
		"  *   - .txt   Ascii full precision representation (sparse)\n"
		"  *            Whitespace separated, aligned.\n"
		"  *            Comments with # % or /\n"
		"  *            Uses C locale\n"
		"  *            Structural zeros represented by 00\n"
		"  *            Does not scale well for large sparse matrices\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1284\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_from_file", _wrap_DM_from_file, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  from_file(str filename, str format_hint) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_DM", _wrap_new_DM, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  DM()\n"
		"  DM(Sparsity sp)\n"
		"  DM(float val)\n"
		"  DM([[float]] m)\n"
		"  DM(DM m)\n"
		"  DM([SXElem] x)\n"
		"  DM(SX x)\n"
		"  DM(int nrow, int ncol)\n"
		"  DM(Sparsity sp, DM d)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_assign", _wrap_DM_assign, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  assign(self, DM rhs)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_full", (PyCFunction)_wrap_DM_full, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  full(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_sparse", (PyCFunction)_wrap_DM_sparse, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  sparse(self) -> PyObject *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_DM", (PyCFunction)_wrap_delete_DM, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  DM(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DM_swigregister", DM_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SXElem", _wrap_new_SXElem, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  SXElem()\n"
		"  SXElem(SXElem other)\n"
		"\n"
		"Default constructor (not-a-number)\n"
		"\n"
		"Object is initialized as not-a-number.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_10j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L78\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.cpp#L46-L49\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  SXElem(SXElem other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  SXElem()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor (not-a-number)\n"
		"\n"
		"Object is initialized as not-a-number.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_10j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L78\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.cpp#L46-L49\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_SXElem", (PyCFunction)_wrap_delete_SXElem, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  SXElem(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L110\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.cpp#L87-L89\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SXElem_swigregister", SXElem_swigregister, METH_VARARGS, NULL},
	 { (char *)"SX_has_nz", _wrap_SX_has_nz, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_nz(self, int rr, int cc) -> bool\n"
		"\n"
		"Returns true if the matrix has a non-zero at location rr, cc.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L219\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L65-L67\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX___bool__", (PyCFunction)_wrap_SX___bool__, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  __bool__(self) -> bool\n"
		"\n"
		"Returns the truth value of a  Matrix.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L222\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L70-L76\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_get", _wrap_SX_get, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Sparsity sp) -> SX\n"
		"  get(self, bool ind1, Slice rr) -> SX\n"
		"  get(self, bool ind1, IM rr) -> SX\n"
		"  get(self, bool ind1, Slice rr, Slice cc) -> SX\n"
		"  get(self, bool ind1, Slice rr, IM cc) -> SX\n"
		"  get(self, bool ind1, IM rr, Slice cc) -> SX\n"
		"  get(self, bool ind1, IM rr, IM cc) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set", _wrap_SX_set, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, SX m, bool ind1, Sparsity sp)\n"
		"  set(self, SX m, bool ind1, Slice rr)\n"
		"  set(self, SX m, bool ind1, IM rr)\n"
		"  set(self, SX m, bool ind1, Slice rr, Slice cc)\n"
		"  set(self, SX m, bool ind1, Slice rr, IM cc)\n"
		"  set(self, SX m, bool ind1, IM rr, Slice cc)\n"
		"  set(self, SX m, bool ind1, IM rr, IM cc)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_get_nz", _wrap_SX_get_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, Slice k) -> SX\n"
		"  get_nz(self, bool ind1, IM k) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set_nz", _wrap_SX_set_nz, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, SX m, bool ind1, Slice k)\n"
		"  set_nz(self, SX m, bool ind1, IM k)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX___pos__", (PyCFunction)_wrap_SX___pos__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __pos__(self) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX___neg__", (PyCFunction)_wrap_SX___neg__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __neg__(self) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_binary", _wrap_SX_binary, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  binary(int op, SX x, SX y) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_unary", _wrap_SX_unary, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  unary(int op, SX x) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_scalar_matrix", _wrap_SX_scalar_matrix, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  scalar_matrix(int op, SX x, SX y) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_matrix_scalar", _wrap_SX_matrix_scalar, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  matrix_scalar(int op, SX x, SX y) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_matrix_matrix", _wrap_SX_matrix_matrix, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  matrix_matrix(int op, SX x, SX y) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_printme", _wrap_SX_printme, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  printme(self, SX y) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set_max_depth", _wrap_SX_set_max_depth, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_max_depth(int eq_depth)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_get_max_depth", (PyCFunction)_wrap_SX_get_max_depth, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_max_depth() -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_get_input", (PyCFunction)_wrap_SX_get_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_input(Function f) -> [SX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_get_free", (PyCFunction)_wrap_SX_get_free, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_free(Function f) -> [SX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_type_name", (PyCFunction)_wrap_SX_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_print_split", (PyCFunction)_wrap_SX_print_split, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_split(self) -> ([str] OUTPUT, [str] OUTPUT)\n"
		"\n"
		"Get strings corresponding to the nonzeros and the \n"
		"interdependencies.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L873\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L696-L700\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_disp", _wrap_SX_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print a representation of the object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L877\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_str", _wrap_SX_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L880\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_print_scalar", (PyCFunction)_wrap_SX_print_scalar, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_scalar(self)\n"
		"\n"
		"Print scalar.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L883\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L609-L633\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_print_vector", _wrap_SX_print_vector, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_vector(self, bool truncate)\n"
		"\n"
		"Print vector-style.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L886\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L636-L638\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_print_dense", _wrap_SX_print_dense, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_dense(self, bool truncate)\n"
		"\n"
		"Print dense matrix-stype.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L889\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L686-L688\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_print_sparse", _wrap_SX_print_sparse, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_sparse(self, bool truncate)\n"
		"\n"
		"Print sparse matrix style.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L892\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_impl.hpp#L691-L693\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_clear", (PyCFunction)_wrap_SX_clear, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  clear(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_resize", _wrap_SX_resize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  resize(self, int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_reserve", _wrap_SX_reserve, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reserve(self, int nnz)\n"
		"  reserve(self, int nnz, int ncol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_erase", _wrap_SX_erase, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L929\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase elements of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L937\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L929\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_remove", _wrap_SX_remove, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  remove(self, [int] rr, [int] cc)\n"
		"\n"
		"Remove columns and rows.\n"
		"\n"
		"Remove/delete rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L944\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_enlarge", _wrap_SX_enlarge, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Enlarge matrix.\n"
		"\n"
		"Make the matrix larger by inserting empty rows and columns, keeping \n"
		"the \n"
		"existing non-zeros\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19i\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L952\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_sparsity", (PyCFunction)_wrap_SX_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get an owning reference to the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L979\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_triplet", _wrap_SX_triplet, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  triplet([int] row, [int] col, SX d) -> SX\n"
		"  triplet([int] row, [int] col, SX d, (int,int) rc) -> SX\n"
		"  triplet([int] row, [int] col, SX d, int nrow, int ncol) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_inf", _wrap_SX_inf, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol) -> SX\n"
		"  inf((int,int) rc) -> SX\n"
		"  inf(Sparsity sp) -> SX\n"
		"\n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1004\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1004\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1005\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1003\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_nan", _wrap_SX_nan, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol) -> SX\n"
		"  nan((int,int) rc) -> SX\n"
		"  nan(Sparsity sp) -> SX\n"
		"\n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1013\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1013\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1014\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1012\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_eye", (PyCFunction)_wrap_SX_eye, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  eye(int n) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_element_hash", (PyCFunction)_wrap_SX_element_hash, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  element_hash(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_regular", (PyCFunction)_wrap_SX_is_regular, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_regular(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_smooth", (PyCFunction)_wrap_SX_is_smooth, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_smooth(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_leaf", (PyCFunction)_wrap_SX_is_leaf, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_leaf(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_commutative", (PyCFunction)_wrap_SX_is_commutative, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_commutative(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_symbolic", (PyCFunction)_wrap_SX_is_symbolic, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_symbolic(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_valid_input", (PyCFunction)_wrap_SX_is_valid_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_valid_input(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_has_duplicates", (PyCFunction)_wrap_SX_has_duplicates, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_duplicates(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_reset_input", (PyCFunction)_wrap_SX_reset_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  reset_input(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_constant", (PyCFunction)_wrap_SX_is_constant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_constant(self) -> bool\n"
		"\n"
		"Check if the matrix is constant (note that false negative \n"
		"answers are \n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19v\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1100\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_integer", (PyCFunction)_wrap_SX_is_integer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_integer(self) -> bool\n"
		"\n"
		"Check if the matrix is integer-valued.\n"
		"\n"
		"(note that false negative answers are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1107\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_zero", (PyCFunction)_wrap_SX_is_zero, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_zero(self) -> bool\n"
		"\n"
		"check if the matrix is 0 (note that false negative answers are \n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1112\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_one", (PyCFunction)_wrap_SX_is_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_one(self) -> bool\n"
		"\n"
		"check if the matrix is 1 (note that false negative answers are \n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_minus_one", (PyCFunction)_wrap_SX_is_minus_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_minus_one(self) -> bool\n"
		"\n"
		"check if the matrix is -1 (note that false negative answers are\n"
		"\n"
		"possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1122\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_eye", (PyCFunction)_wrap_SX_is_eye, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_eye(self) -> bool\n"
		"\n"
		"check if the matrix is an identity matrix (note that false \n"
		"negative \n"
		"answers\n"
		"\n"
		"are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1129\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_op", (PyCFunction)_wrap_SX_op, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  op(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_is_op", _wrap_SX_is_op, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  is_op(self, int op) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_has_zeros", (PyCFunction)_wrap_SX_has_zeros, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_zeros(self) -> bool\n"
		"\n"
		"Check if the matrix has any zero entries which are not \n"
		"structural \n"
		"zeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1140\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_nonzeros", (PyCFunction)_wrap_SX_nonzeros, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nonzeros(self) -> [SXElem]\n"
		"\n"
		"Get all nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1157\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_elements", (PyCFunction)_wrap_SX_elements, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  elements(self) -> [SXElem]\n"
		"\n"
		"Get all elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1150\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX___float__", (PyCFunction)_wrap_SX___float__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __float__(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX___int__", (PyCFunction)_wrap_SX___int__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __int__(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_name", (PyCFunction)_wrap_SX_name, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  name(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_dep", _wrap_SX_dep, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  dep(self, int ch) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_n_dep", (PyCFunction)_wrap_SX_n_dep, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  n_dep(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set_precision", (PyCFunction)_wrap_SX_set_precision, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_precision(int precision)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set_width", (PyCFunction)_wrap_SX_set_width, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_width(int width)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_set_scientific", (PyCFunction)_wrap_SX_set_scientific, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_scientific(bool scientific)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_rng", (PyCFunction)_wrap_SX_rng, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rng(int seed)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_rand", _wrap_SX_rand, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  rand(int nrow, int ncol) -> SX\n"
		"  rand((int,int) rc) -> SX\n"
		"  rand(Sparsity sp) -> SX\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a matrix with uniformly distributed random numbers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ab\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1212\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rand((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a matrix with uniformly distributed random numbers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ab\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1216\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_export_code", _wrap_SX_export_code, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, dict options)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_info", (PyCFunction)_wrap_SX_info, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_serialize", _wrap_SX_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self) -> str\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ae\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1249\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ah\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1264\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Serialize.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ae\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1249\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_deserialize", _wrap_SX_deserialize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(std::istream & stream) -> SX\n"
		"  deserialize(casadi::DeserializingStream & s) -> SX\n"
		"  deserialize(str s) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_to_file", _wrap_SX_to_file, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  to_file(self, str filename, str format)\n"
		"\n"
		"Export numerical matrix to file\n"
		"\n"
		"Supported formats:\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  *   - .mtx   Matrix Market (sparse)\n"
		"  *   - .txt   Ascii full precision representation (sparse)\n"
		"  *            Whitespace separated, aligned.\n"
		"  *            Comments with # % or /\n"
		"  *            Uses C locale\n"
		"  *            Structural zeros represented by 00\n"
		"  *            Does not scale well for large sparse matrices\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L1284\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_from_file", _wrap_SX_from_file, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  from_file(str filename, str format_hint) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_SX", _wrap_new_SX, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  SX()\n"
		"  SX(Sparsity sp)\n"
		"  SX(float val)\n"
		"  SX([[float]] m)\n"
		"  SX([float] x)\n"
		"  SX(DM x)\n"
		"  SX(SX m)\n"
		"  SX(int nrow, int ncol)\n"
		"  SX(Sparsity sp, SX d)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_SX", (PyCFunction)_wrap_delete_SX, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  SX(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SX_swigregister", SX_swigregister, METH_VARARGS, NULL},
	 { (char *)"MX_type_name", (PyCFunction)_wrap_MX_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_MX", (PyCFunction)_wrap_delete_MX, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MX(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX___bool__", (PyCFunction)_wrap_MX___bool__, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  __bool__(self) -> bool\n"
		"\n"
		"Returns the truth value of an  MX expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L184\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L137-L139\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_sparsity", (PyCFunction)_wrap_MX_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get an owning reference to the sparsity pattern.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L189-L189\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_erase", _wrap_MX_erase, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qe\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L196\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L590-L602\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase elements of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L204\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L604-L616\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  erase(self, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Erase a submatrix (leaving structural zeros in its place)\n"
		"\n"
		"Erase rows and/or columns of a matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qe\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L196\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L590-L602\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_enlarge", _wrap_MX_enlarge, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)\n"
		"\n"
		"Enlarge matrix.\n"
		"\n"
		"Make the matrix larger by inserting empty rows and columns, keeping \n"
		"the \n"
		"existing non-zeros\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L211\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L618-L626\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX___neg__", (PyCFunction)_wrap_MX___neg__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __neg__(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_dep", _wrap_MX_dep, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dep(self, int ch) -> MX\n"
		"\n"
		"Get the nth dependency as  MX.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L236\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L730-L732\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_n_out", (PyCFunction)_wrap_MX_n_out, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_out(self) -> int\n"
		"\n"
		"Number of outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L241\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L841-L843\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_output", _wrap_MX_get_output, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_output(self, int oind) -> MX\n"
		"\n"
		"Get an output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ql\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L246\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L845-L847\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_n_dep", (PyCFunction)_wrap_MX_n_dep, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_dep(self) -> int\n"
		"\n"
		"Get the number of dependencies of a binary  SXElem.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L251\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L734-L736\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_name", (PyCFunction)_wrap_MX_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  name(self) -> str\n"
		"\n"
		"Get the name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L254\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L738-L740\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX___float__", (PyCFunction)_wrap_MX___float__, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __float__(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_to_DM", (PyCFunction)_wrap_MX_to_DM, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  to_DM(self) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_symbolic", (PyCFunction)_wrap_MX_is_symbolic, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_symbolic(self) -> bool\n"
		"\n"
		"Check if symbolic.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L263\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L742-L744\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_constant", (PyCFunction)_wrap_MX_is_constant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_constant(self) -> bool\n"
		"\n"
		"Check if constant.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L266\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L746-L748\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_call", (PyCFunction)_wrap_MX_is_call, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_call(self) -> bool\n"
		"\n"
		"Check if evaluation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L269\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L750-L752\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_which_function", (PyCFunction)_wrap_MX_which_function, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  which_function(self) -> Function\n"
		"\n"
		"Get function - only valid when  is_call() is true.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L272\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L754-L756\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_output", (PyCFunction)_wrap_MX_is_output, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_output(self) -> bool\n"
		"\n"
		"Check if evaluation output.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L275\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L758-L760\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_which_output", (PyCFunction)_wrap_MX_which_output, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  which_output(self) -> int\n"
		"\n"
		"Get the index of evaluation output - only valid when  \n"
		"is_output() is true.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L278\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L762-L764\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_op", _wrap_MX_is_op, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_op(self, int op) -> bool\n"
		"\n"
		"Is it a certain operation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L281\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L766-L768\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_multiplication", (PyCFunction)_wrap_MX_is_multiplication, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_multiplication(self) -> bool\n"
		"\n"
		"Check if multiplication.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L284\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L770-L772\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_commutative", (PyCFunction)_wrap_MX_is_commutative, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_commutative(self) -> bool\n"
		"\n"
		"Check if commutative operation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L287\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L822-L827\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_norm", (PyCFunction)_wrap_MX_is_norm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_norm(self) -> bool\n"
		"\n"
		"Check if norm.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L290\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L774-L776\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_valid_input", (PyCFunction)_wrap_MX_is_valid_input, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_valid_input(self) -> bool\n"
		"\n"
		"Check if matrix can be used to define function inputs.\n"
		"\n"
		"Valid inputs for MXFunctions are combinations of Reshape, \n"
		"concatenations \n"
		"and SymbolicMX\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L297\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L897-L899\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_n_primitives", (PyCFunction)_wrap_MX_n_primitives, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_primitives(self) -> int\n"
		"\n"
		"Get the number of primitives for MXFunction inputs/outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qo\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L302\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L901-L903\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_primitives", (PyCFunction)_wrap_MX_primitives, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  primitives(self) -> [MX]\n"
		"\n"
		"Get primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L307\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L905-L911\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_split_primitives", _wrap_MX_split_primitives, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  split_primitives(self, MX x) -> [MX]\n"
		"\n"
		"Split up an expression along symbolic primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L312\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L913-L919\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_join_primitives", _wrap_MX_join_primitives, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  join_primitives(self, [MX] v) -> MX\n"
		"\n"
		"Join an expression along symbolic primitives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L317\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L921-L927\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_has_duplicates", (PyCFunction)_wrap_MX_has_duplicates, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_duplicates(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_reset_input", (PyCFunction)_wrap_MX_reset_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  reset_input(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_eye", (PyCFunction)_wrap_MX_is_eye, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_eye(self) -> bool\n"
		"\n"
		"check if identity\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L339\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L937-L939\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_zero", (PyCFunction)_wrap_MX_is_zero, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_zero(self) -> bool\n"
		"\n"
		"check if zero (note that false negative answers are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L344\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L941-L947\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_one", (PyCFunction)_wrap_MX_is_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_one(self) -> bool\n"
		"\n"
		"check if zero (note that false negative answers are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L349\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L949-L951\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_minus_one", (PyCFunction)_wrap_MX_is_minus_one, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_minus_one(self) -> bool\n"
		"\n"
		"check if zero (note that false negative answers are possible)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L354\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L953-L955\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_transpose", (PyCFunction)_wrap_MX_is_transpose, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_transpose(self) -> bool\n"
		"\n"
		"Is the expression a transpose?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L359\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L957-L959\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_regular", (PyCFunction)_wrap_MX_is_regular, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_regular(self) -> bool\n"
		"\n"
		"Checks if expression does not contain NaN or Inf.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L362\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L961-L967\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_binary", (PyCFunction)_wrap_MX_is_binary, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_binary(self) -> bool\n"
		"\n"
		"Is binary operation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L365\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L786-L788\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_is_unary", (PyCFunction)_wrap_MX_is_unary, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_unary(self) -> bool\n"
		"\n"
		"Is unary operation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L368\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L790-L792\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_op", (PyCFunction)_wrap_MX_op, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  op(self) -> int\n"
		"\n"
		"Get operation type.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L371\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L794-L796\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_info", (PyCFunction)_wrap_MX_info, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"Obtain information about node\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L374\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L798-L800\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_serialize", _wrap_MX_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_qz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L379\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L802-L804\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_deserialize", (PyCFunction)_wrap_MX_deserialize, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(casadi::DeserializingStream & s) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_temp", (PyCFunction)_wrap_MX_get_temp, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_temp(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_set_temp", _wrap_MX_set_temp, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_temp(self, int t)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_binary", _wrap_MX_binary, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  binary(int op, MX x, MX y) -> MX\n"
		"\n"
		"Create nodes by their ID.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L398\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L507-L532\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_unary", _wrap_MX_unary, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unary(int op, MX x) -> MX\n"
		"\n"
		"Create nodes by their ID.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L399\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L534-L536\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_inf", _wrap_MX_inf, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol) -> MX\n"
		"  inf((int,int) rc) -> MX\n"
		"  inf(Sparsity sp) -> MX\n"
		"\n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L407\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L550-L552\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L407\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L550-L552\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L408\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L554-L556\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  inf(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all inf\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L406\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L558-L560\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_nan", _wrap_MX_nan, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol) -> MX\n"
		"  nan((int,int) rc) -> MX\n"
		"  nan(Sparsity sp) -> MX\n"
		"\n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L416\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L562-L564\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L416\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L562-L564\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan((int,int) rc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L417\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L566-L568\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nan(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"create a matrix with all nan\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L415\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L570-L572\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_eye", (PyCFunction)_wrap_MX_eye, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  eye(int n) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get", _wrap_MX_get, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, int rr) -> MX\n"
		"  get(self, bool ind1, Sparsity sp) -> MX\n"
		"  get(self, bool ind1, Slice rr) -> MX\n"
		"  get(self, bool ind1, IM rr) -> MX\n"
		"  get(self, bool ind1, MX rr) -> MX\n"
		"  get(self, bool ind1, int rr, int cc) -> MX\n"
		"  get(self, bool ind1, int rr, Slice cc) -> MX\n"
		"  get(self, bool ind1, Slice rr, int cc) -> MX\n"
		"  get(self, bool ind1, Slice rr, Slice cc) -> MX\n"
		"  get(self, bool ind1, Slice rr, IM cc) -> MX\n"
		"  get(self, bool ind1, Slice rr, MX cc) -> MX\n"
		"  get(self, bool ind1, IM rr, Slice cc) -> MX\n"
		"  get(self, bool ind1, IM rr, IM cc) -> MX\n"
		"  get(self, bool ind1, MX rr, Slice cc) -> MX\n"
		"  get(self, bool ind1, MX rr, MX cc) -> MX\n"
		"\n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L459\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L208-L211\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, IM rr)\n"
		"  get(self, bool ind1, Slice rr, IM cc)\n"
		"  get(self, bool ind1, IM rr, Slice cc)\n"
		"  get(self, bool ind1, IM rr, IM cc)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, int rr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L436\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L436-L438\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L434\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L194-L200\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Slice rr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L432\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L171-L174\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, MX rr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L435\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L202-L206\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, int rr, int cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L454\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L454-L457\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, int rr, Slice cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L449\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L449-L451\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Slice rr, int cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L445\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L445-L447\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Slice rr, Slice cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L443\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L141-L144\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, Slice rr, MX cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L459\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L208-L211\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, MX rr, Slice cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L458\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L213-L216\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, bool ind1, MX rr, MX cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L460\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L218-L221\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_set", _wrap_MX_set, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, MX m, bool ind1, Sparsity sp)\n"
		"  set(self, MX m, bool ind1, Slice rr)\n"
		"  set(self, MX m, bool ind1, IM rr)\n"
		"  set(self, MX m, bool ind1, Slice rr, Slice cc)\n"
		"  set(self, MX m, bool ind1, Slice rr, IM cc)\n"
		"  set(self, MX m, bool ind1, IM rr, Slice cc)\n"
		"  set(self, MX m, bool ind1, IM rr, IM cc)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, MX m, bool ind1, IM rr)\n"
		"  set(self, MX m, bool ind1, Slice rr, IM cc)\n"
		"  set(self, MX m, bool ind1, IM rr, Slice cc)\n"
		"  set(self, MX m, bool ind1, IM rr, IM cc)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, MX m, bool ind1, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L467\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L371-L382\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, MX m, bool ind1, Slice rr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a submatrix, single argument\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L465\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L298-L301\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, MX m, bool ind1, Slice rr, Slice cc)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a submatrix, two arguments\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L472\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L223-L226\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_nz", _wrap_MX_get_nz, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, int kk) -> MX\n"
		"  get_nz(self, bool ind1, Slice kk) -> MX\n"
		"  get_nz(self, bool ind1, IM kk) -> MX\n"
		"  get_nz(self, bool ind1, MX kk) -> MX\n"
		"  get_nz(self, bool ind1, Slice inner, MX outer) -> MX\n"
		"  get_nz(self, bool ind1, MX inner, Slice outer) -> MX\n"
		"  get_nz(self, bool ind1, MX inner, MX outer) -> MX\n"
		"\n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L487\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L432-L435\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, IM kk)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, int kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L483\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L483-L485\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, Slice kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L480\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L384-L387\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, MX kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L482\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L422-L425\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, Slice inner, MX outer)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L487\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L432-L435\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, MX inner, Slice outer)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L486\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L437-L440\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_nz(self, bool ind1, MX inner, MX outer)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L488\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L427-L430\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_set_nz", _wrap_MX_set_nz, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, MX m, bool ind1, int kk)\n"
		"  set_nz(self, MX m, bool ind1, Slice kk)\n"
		"  set_nz(self, MX m, bool ind1, IM kk)\n"
		"  set_nz(self, MX m, bool ind1, MX kk)\n"
		"\n"
		"Set a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L495\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L503-L505\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, MX m, bool ind1, IM kk)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, MX m, bool ind1, int kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L496\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L496-L496\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, MX m, bool ind1, Slice kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L493\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L442-L445\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nz(self, MX m, bool ind1, MX kk)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set a set of nonzeros\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L495\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L503-L505\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_einstein", _wrap_MX_einstein, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX\n"
		"  einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX\n"
		"\n"
		"Computes an einstein dense tensor contraction.\n"
		"\n"
		"Computes the product: C_c = A_a + B_b where a b c are index/einstein \n"
		"\n"
		"notation in an encoded form\n"
		"\n"
		"For example, an matrix-matrix product may be written as: C_ij = A_ik \n"
		"B_kj\n"
		"\n"
		"The encoded form uses strictly negative numbers to indicate labels. \n"
		"For the\n"
		" above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L638-L644\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Computes an einstein dense tensor contraction.\n"
		"\n"
		"Computes the product: C_c = A_a + B_b where a b c are index/einstein \n"
		"\n"
		"notation in an encoded form\n"
		"\n"
		"For example, an matrix-matrix product may be written as: C_ij = A_ik \n"
		"B_kj\n"
		"\n"
		"The encoded form uses strictly negative numbers to indicate labels. \n"
		"For the\n"
		" above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L520\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L646-L652\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Computes an einstein dense tensor contraction.\n"
		"\n"
		"Computes the product: C_c = A_a + B_b where a b c are index/einstein \n"
		"\n"
		"notation in an encoded form\n"
		"\n"
		"For example, an matrix-matrix product may be written as: C_ij = A_ik \n"
		"B_kj\n"
		"\n"
		"The encoded form uses strictly negative numbers to indicate labels. \n"
		"For the\n"
		" above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L638-L644\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_bspline_dual", _wrap_MX_bspline_dual, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  bspline_dual([float] x, [[float]] knots, [int] degree, dict opts) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_interpn_linear", _wrap_MX_interpn_linear, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  interpn_linear([MX] x, MX v, [MX] xq, dict opts) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_printme", _wrap_MX_printme, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  printme(self, MX b) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_attachAssert", _wrap_MX_attachAssert, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  attachAssert(self, MX y, str fail_message) -> MX\n"
		"\n"
		"returns itself, but with an assertion attached\n"
		"\n"
		"If y does not evaluate to 1, a runtime error is raised\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L851\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L699-L704\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_monitor", _wrap_MX_monitor, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  monitor(self, str comment) -> MX\n"
		"\n"
		"Monitor an expression.\n"
		"\n"
		"Returns itself, but with the side effect of printing the nonzeros \n"
		"along \n"
		"with a comment\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L858\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L706-L708\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_mapping", (PyCFunction)_wrap_MX_mapping, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mapping(self) -> IM\n"
		"\n"
		"Get an IM representation of a GetNonzeros or SetNonzeros node.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ri\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L866\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L829-L831\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_set_max_depth", _wrap_MX_set_max_depth, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  set_max_depth(int eq_depth)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_max_depth", (PyCFunction)_wrap_MX_get_max_depth, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_max_depth() -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_test_cast", (PyCFunction)_wrap_MX_test_cast, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  test_cast(casadi::SharedObjectInternal const * ptr) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_input", (PyCFunction)_wrap_MX_get_input, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_input(Function f) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_get_free", (PyCFunction)_wrap_MX_get_free, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  get_free(Function f) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_eval_mx", _wrap_MX_eval_mx, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  eval_mx(self, [MX] arg) -> [MX]\n"
		"\n"
		"Evaluate the  MX node with new symbolic dependencies.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L897\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L2288-L2294\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_MX", _wrap_new_MX, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MX()\n"
		"  MX(Sparsity sp)\n"
		"  MX(float x)\n"
		"  MX(DM x)\n"
		"  MX(MX other)\n"
		"  MX(int nrow, int ncol)\n"
		"  MX(Sparsity sp, MX val)\n"
		"  MX(Sparsity sp, str fname)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(DM x)\n"
		"  MX(MX other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L94\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L57-L59\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(int nrow, int ncol)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a sparse matrix with all structural zeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L106-L108\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a sparse matrix from a sparsity pattern.\n"
		"\n"
		"Same as MX::ones(sparsity)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L113\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L102-L104\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(float x)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create scalar constant (also implicit type conversion)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L128\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L69-L71\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(Sparsity sp, MX val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct matrix with a given sparsity and nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L118\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L81-L100\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  MX(Sparsity sp, str fname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct matrix with a given sparsity and a file with nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_q5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L123\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L118-L120\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MX_swigregister", MX_swigregister, METH_VARARGS, NULL},
	 { (char *)"Function_type_name", (PyCFunction)_wrap_Function_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_jit", _wrap_Function_jit, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  jit(str name, str body, [str] name_in, [str] name_out, dict opts) -> Function\n"
		"  jit(str name, str body, [str] name_in, [str] name_out, [Sparsity] sparsity_in, [Sparsity] sparsity_out, dict opts) -> Function\n"
		"\n"
		"Create a just-in-time compiled function from a C language \n"
		"string.\n"
		"\n"
		"The names and sparsity patterns of all the inputs and outputs must be \n"
		"\n"
		"provided. If sparsities are not provided, all inputs and outputs are \n"
		"\n"
		"assumed to be scalar. Only specify the function body, assuming that \n"
		"input \n"
		"and output nonzeros are stored in arrays with the specified \n"
		"naming \n"
		"convension. The data type used is 'casadi_real', which is \n"
		"typically equal \n"
		"to 'double or another data type with the same API as 'double.\n"
		"\n"
		"Inputs may be null pointers. This means that the all entries are zero.\n"
		"\n"
		"Outputs may be null points. This means that the corresponding result \n"
		"can be\n"
		" ignored.\n"
		"\n"
		"If an error occurs in the evaluation, issue \"return 1;\";\n"
		"\n"
		"The final generated function will have a structure similar to:\n"
		"\n"
		"casadi_int fname(const casadi_real** arg, casadi_real** res, \n"
		"casadi_int* \n"
		"iw, casadi_real* w, void* mem) { const casadi_real *x1, \n"
		"*x2; casadi_real \n"
		"*r1, *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 =\n"
		" *res++; \n"
		"<FUNCTION_BODY> return 0; }\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L185\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L284-L291\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  jit(str name, str body, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a just-in-time compiled function from a C language \n"
		"string.\n"
		"\n"
		"The names and sparsity patterns of all the inputs and outputs must be \n"
		"\n"
		"provided. If sparsities are not provided, all inputs and outputs are \n"
		"\n"
		"assumed to be scalar. Only specify the function body, assuming that \n"
		"input \n"
		"and output nonzeros are stored in arrays with the specified \n"
		"naming \n"
		"convension. The data type used is 'casadi_real', which is \n"
		"typically equal \n"
		"to 'double or another data type with the same API as 'double.\n"
		"\n"
		"Inputs may be null pointers. This means that the all entries are zero.\n"
		"\n"
		"Outputs may be null points. This means that the corresponding result \n"
		"can be\n"
		" ignored.\n"
		"\n"
		"If an error occurs in the evaluation, issue \"return 1;\";\n"
		"\n"
		"The final generated function will have a structure similar to:\n"
		"\n"
		"casadi_int fname(const casadi_real** arg, casadi_real** res, \n"
		"casadi_int* \n"
		"iw, casadi_real* w, void* mem) { const casadi_real *x1, \n"
		"*x2; casadi_real \n"
		"*r1, *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 =\n"
		" *res++; \n"
		"<FUNCTION_BODY> return 0; }\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L185\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L284-L291\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  jit(str name, str body, [str] name_in, [str] name_out, [Sparsity] sparsity_in, [Sparsity] sparsity_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a just-in-time compiled function from a C language \n"
		"string.\n"
		"\n"
		"The names and sparsity patterns of all the inputs and outputs must be \n"
		"\n"
		"provided. If sparsities are not provided, all inputs and outputs are \n"
		"\n"
		"assumed to be scalar. Only specify the function body, assuming that \n"
		"input \n"
		"and output nonzeros are stored in arrays with the specified \n"
		"naming \n"
		"convension. The data type used is 'casadi_real', which is \n"
		"typically equal \n"
		"to 'double or another data type with the same API as 'double.\n"
		"\n"
		"Inputs may be null pointers. This means that the all entries are zero.\n"
		"\n"
		"Outputs may be null points. This means that the corresponding result \n"
		"can be\n"
		" ignored.\n"
		"\n"
		"If an error occurs in the evaluation, issue \"return 1;\";\n"
		"\n"
		"The final generated function will have a structure similar to:\n"
		"\n"
		"casadi_int fname(const casadi_real** arg, casadi_real** res, \n"
		"casadi_int* \n"
		"iw, casadi_real* w, void* mem) { const casadi_real *x1, \n"
		"*x2; casadi_real \n"
		"*r1, *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 =\n"
		" *res++; \n"
		"<FUNCTION_BODY> return 0; }\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L293-L305\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Function", (PyCFunction)_wrap_delete_Function, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Function(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L60-L61\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_expand", _wrap_Function_expand, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  expand(self) -> Function\n"
		"  expand(self, str name, dict opts) -> Function\n"
		"\n"
		"Expand a function to SX.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L206\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L307-L315\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  expand(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Expand a function to SX.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L206\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L307-L315\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  expand(self, str name, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Expand a function to SX.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L317-L333\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_n_in", (PyCFunction)_wrap_Function_n_in, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_in(self) -> int\n"
		"\n"
		"Get the number of function inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L228\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L818-L820\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_n_out", (PyCFunction)_wrap_Function_n_out, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_out(self) -> int\n"
		"\n"
		"Get the number of function outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L233\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L822-L824\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size1_in", _wrap_Function_size1_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size1_in(self, int ind) -> int\n"
		"  size1_in(self, str iname) -> int\n"
		"\n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L239\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L826-L828\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size1_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L239\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L826-L828\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size1_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L240\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L240-L240\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size2_in", _wrap_Function_size2_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size2_in(self, int ind) -> int\n"
		"  size2_in(self, str iname) -> int\n"
		"\n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L241\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L830-L832\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size2_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L241\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L830-L832\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size2_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L242\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L242-L242\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size_in", _wrap_Function_size_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size_in(self, int ind) -> (int,int)\n"
		"  size_in(self, str iname) -> (int,int)\n"
		"\n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L243\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L842-L844\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L243\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L842-L844\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1va\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L244\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L244-L246\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size1_out", _wrap_Function_size1_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size1_out(self, int ind) -> int\n"
		"  size1_out(self, str oname) -> int\n"
		"\n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L253\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L834-L836\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size1_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L253\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L834-L836\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size1_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L254\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L254-L254\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size2_out", _wrap_Function_size2_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size2_out(self, int ind) -> int\n"
		"  size2_out(self, str oname) -> int\n"
		"\n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L255\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L838-L840\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size2_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L255\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L838-L840\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size2_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L256\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L256-L256\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_size_out", _wrap_Function_size_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  size_out(self, int ind) -> (int,int)\n"
		"  size_out(self, str oname) -> (int,int)\n"
		"\n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L257\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L846-L848\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L257\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L846-L848\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  size_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output dimension.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L258\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L258-L260\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nnz_in", _wrap_Function_nnz_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_in(self) -> int\n"
		"  nnz_in(self, int ind) -> int\n"
		"  nnz_in(self, str iname) -> int\n"
		"\n"
		"Get number of input nonzeros.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L270\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L866-L868\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input nonzeros.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L269\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L850-L852\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input nonzeros.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L270\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L866-L868\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input nonzeros.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L271\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L271-L271\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nnz_out", _wrap_Function_nnz_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nnz_out(self) -> int\n"
		"  nnz_out(self, int ind) -> int\n"
		"  nnz_out(self, str oname) -> int\n"
		"\n"
		"Get number of output nonzeros.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L281\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L870-L872\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output nonzeros.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L280\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L854-L856\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output nonzeros.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L281\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L870-L872\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nnz_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output nonzeros.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L282\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L282-L282\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_numel_in", _wrap_Function_numel_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel_in(self) -> int\n"
		"  numel_in(self, int ind) -> int\n"
		"  numel_in(self, str iname) -> int\n"
		"\n"
		"Get number of input elements.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ve\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L292\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L874-L876\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input elements.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ve\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L291\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L858-L860\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input elements.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ve\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L292\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L874-L876\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of input elements.\n"
		"\n"
		"For a particular input or for all of the inputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ve\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L293\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L293-L293\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_numel_out", _wrap_Function_numel_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel_out(self) -> int\n"
		"  numel_out(self, int ind) -> int\n"
		"  numel_out(self, str oname) -> int\n"
		"\n"
		"Get number of output elements.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L303\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L878-L880\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output elements.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L302\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L862-L864\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output elements.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L303\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L878-L880\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  numel_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get number of output elements.\n"
		"\n"
		"For a particular output or for all of the outputs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L304\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L304-L304\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_name_in", _wrap_Function_name_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  name_in(self) -> [str]\n"
		"  name_in(self, int ind) -> str\n"
		"\n"
		"Get input scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L310\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L950-L952\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  name_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L320\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L974-L980\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  name_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L310\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L950-L952\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_name_out", _wrap_Function_name_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  name_out(self) -> [str]\n"
		"  name_out(self, int ind) -> str\n"
		"\n"
		"Get output scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L315\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L954-L956\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  name_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L325\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L982-L988\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  name_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L315\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L954-L956\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_index_in", _wrap_Function_index_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  index_in(self, str name) -> int\n"
		"\n"
		"Find the index for a string describing a particular entry of an \n"
		"input \n"
		"scheme.\n"
		"\n"
		"example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if \n"
		"FunctionInternal \n"
		"adheres to SCHEME_NLPINput\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L333\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L958-L964\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_index_out", _wrap_Function_index_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  index_out(self, str name) -> int\n"
		"\n"
		"Find the index for a string describing a particular entry of an \n"
		"output\n"
		" scheme.\n"
		"\n"
		"example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if \n"
		"FunctionInternal \n"
		"adheres to SCHEME_NLPINput\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L341\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L966-L972\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_default_in", _wrap_Function_default_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  default_in(self, int ind) -> float\n"
		"\n"
		"Get default input value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L346\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1454-L1456\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_max_in", _wrap_Function_max_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  max_in(self, int ind) -> float\n"
		"\n"
		"Get largest input value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L351\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1458-L1460\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_min_in", _wrap_Function_min_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  min_in(self, int ind) -> float\n"
		"\n"
		"Get smallest input value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vo\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L356\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1462-L1464\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nominal_in", _wrap_Function_nominal_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nominal_in(self, int ind) -> [float]\n"
		"\n"
		"Get nominal input value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L361\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1466-L1468\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nominal_out", _wrap_Function_nominal_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nominal_out(self, int ind) -> [float]\n"
		"\n"
		"Get nominal output value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L366\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1470-L1472\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sparsity_in", _wrap_Function_sparsity_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_in(self, int ind) -> Sparsity\n"
		"  sparsity_in(self, str iname) -> Sparsity\n"
		"\n"
		"Get sparsity of a given input.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L372\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L990-L996\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get sparsity of a given input.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L372\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L990-L996\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get sparsity of a given input.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L373\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L998-L1004\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sparsity_out", _wrap_Function_sparsity_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_out(self, int ind) -> Sparsity\n"
		"  sparsity_out(self, str iname) -> Sparsity\n"
		"\n"
		"Get sparsity of a given output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L380\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1006-L1012\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get sparsity of a given output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L380\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1006-L1012\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_out(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get sparsity of a given output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L381\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1014-L1020\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_is_diff_in", _wrap_Function_is_diff_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_in(self) -> [bool]\n"
		"  is_diff_in(self, int ind) -> bool\n"
		"\n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L388\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1022-L1028\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L390\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1038-L1044\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L388\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1022-L1028\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_is_diff_out", _wrap_Function_is_diff_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_out(self) -> [bool]\n"
		"  is_diff_out(self, int ind) -> bool\n"
		"\n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L389\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1030-L1036\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L391\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1046-L1052\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  is_diff_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get differentiability of inputs/output.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L389\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1030-L1036\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_factory", _wrap_Function_factory, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  factory(self, str name, [str] s_in, [str] s_out, dict:[str] aux, dict opts) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_oracle", (PyCFunction)_wrap_Function_oracle, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  oracle(self) -> Function\n"
		"\n"
		"Get oracle.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L407\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1877-L1883\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_wrap", (PyCFunction)_wrap_Function_wrap, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  wrap(self) -> Function\n"
		"\n"
		"Wrap in an  Function instance consisting of only one  MX call.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L412\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1885-L1887\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_wrap_as_needed", _wrap_Function_wrap_as_needed, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  wrap_as_needed(self, dict opts) -> Function\n"
		"\n"
		"Wrap in a  Function with options.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L417\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1889-L1891\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_which_depends", _wrap_Function_which_depends, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  which_depends(self, str s_in, [str] s_out, int order, bool tr) -> [bool]\n"
		"\n"
		"Which variables enter with some order.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"order: \n"
		"Only 1 (linear) and 2 (nonlinear) allowed\n"
		"\n"
		"tr: \n"
		"Flip the relationship. Return which expressions contain the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L425\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1795-L1802\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_print_dimensions", (PyCFunction)_wrap_Function_print_dimensions, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_dimensions(self)\n"
		"\n"
		"Print dimensions of inputs and outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L432\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1126-L1128\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_print_options", (PyCFunction)_wrap_Function_print_options, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_options(self)\n"
		"\n"
		"Print options to a stream.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1vz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L437\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1130-L1132\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_print_option", _wrap_Function_print_option, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  print_option(self, str name)\n"
		"\n"
		"Print all information there is to know about a certain option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L442\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1134-L1136\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_has_option", _wrap_Function_has_option, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_option(self, str option_name) -> bool\n"
		"\n"
		"Does a particular option exist.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L447\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1138-L1145\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_change_option", _wrap_Function_change_option, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  change_option(self, str option_name, GenericType option_value)\n"
		"\n"
		"Change option after object creation for debugging.\n"
		"\n"
		"This is only possible for a selected number of options that do not \n"
		"change \n"
		"the numerical results of the computation, e.g. to enable a more\n"
		" verbose \n"
		"output or saving to file.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L455\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1147-L1157\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_uses_output", (PyCFunction)_wrap_Function_uses_output, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  uses_output(self) -> bool\n"
		"\n"
		"Do the derivative functions need nondifferentiated outputs?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L460\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L882-L884\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_jacobian_old", _wrap_Function_jacobian_old, METH_VARARGS, (char *)"\n"
		"  [DEPRECATED] Replaced by  Function::factory.\n"
		"\n"
		"::\n"
		"\n"
		"  jacobian_old(self, int iind, int oind) -> Function\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L466\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L887-L893\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_hessian_old", _wrap_Function_hessian_old, METH_VARARGS, (char *)"\n"
		"  [DEPRECATED] Replaced by  Function::factory.\n"
		"\n"
		"::\n"
		"\n"
		"  hessian_old(self, int iind, int oind) -> Function\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L471\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L895-L903\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sparsity_jac", _wrap_Function_sparsity_jac, METH_VARARGS, (char *)"\n"
		"  [DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_jac(self, str iind, int oind, bool compact, bool symmetric) -> Sparsity\n"
		"  sparsity_jac(self, int iind, int oind, bool compact, bool symmetric) -> Sparsity\n"
		"  sparsity_jac(self, int iind, str oind, bool compact, bool symmetric) -> Sparsity\n"
		"  sparsity_jac(self, str iind, str oind, bool compact, bool symmetric) -> Sparsity\n"
		"\n"
		"block\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L481\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L481-L484\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_jac(self, str iind, int oind, bool compact, bool symmetric)\n"
		"\n"
		"\n"
		"\n"
		"[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian \n"
		"block\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L477\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L477-L480\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_jac(self, int iind, int oind, bool compact, bool symmetric)\n"
		"\n"
		"\n"
		"\n"
		"[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian \n"
		"block\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L475\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L906-L912\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_jac(self, int iind, str oind, bool compact, bool symmetric)\n"
		"\n"
		"\n"
		"\n"
		"[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian \n"
		"block\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L481\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L481-L484\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_jac(self, str iind, str oind, bool compact, bool symmetric)\n"
		"\n"
		"\n"
		"\n"
		"[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian \n"
		"block\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L485\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L485-L488\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_jacobian", (PyCFunction)_wrap_Function_jacobian, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  jacobian(self) -> Function\n"
		"\n"
		"Calculate all Jacobian blocks.\n"
		"\n"
		"Generates a function that takes all non-differentiated inputs and \n"
		"outputs \n"
		"and calculates all Jacobian blocks. Inputs that are not needed\n"
		" by the \n"
		"routine are all-zero sparse matrices with the correct \n"
		"dimensions.  Output \n"
		"blocks that are not calculated, e.g. if the corresponding input or \n"
		"output \n"
		"is marked non-differentiated are also all-zero sparse. The \n"
		"Jacobian blocks \n"
		"are sorted starting by all the blocks for the first \n"
		"output, then all the \n"
		"blocks for the second output and so on. E.g. f : \n"
		"(x, y) -> (r, s) results \n"
		"in the function jac_f : (x, y, out_r, out_s) \n"
		"-> (jac_r_x, jac_r_y, jac_s_x,\n"
		" jac_s_y)\n"
		"\n"
		"This function is cached.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L508\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L915-L921\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_call", _wrap_Function_call, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  call(self, dict:DM arg, bool always_inline, bool never_inline) -> dict:DM\n"
		"  call(self, [DM] arg, bool always_inline, bool never_inline) -> [DM]\n"
		"  call(self, [SX] arg, bool always_inline, bool never_inline) -> [SX]\n"
		"  call(self, dict:SX arg, bool always_inline, bool never_inline) -> dict:SX\n"
		"  call(self, dict:MX arg, bool always_inline, bool never_inline) -> dict:MX\n"
		"  call(self, [MX] arg, bool always_inline, bool never_inline) -> [MX]\n"
		"\n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L522\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1436-L1443\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, dict:DM arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L520\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1427-L1434\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, [DM] arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L356-L363\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, [SX] arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L516\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L365-L372\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, dict:SX arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L522\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1436-L1443\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, dict:MX arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L524\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1445-L1452\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  call(self, [MX] arg, bool always_inline, bool never_inline)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the function symbolically or numerically.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L518\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L374-L381\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_mapsum", _wrap_Function_mapsum, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mapsum(self, [MX] x, str parallelization) -> [MX]\n"
		"\n"
		"Evaluate symbolically in parallel and sum (matrix graph)\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"parallelization: \n"
		"Type of parallelization used: unroll|serial|openmp\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L642\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L755-L762\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_mapaccum", _wrap_Function_mapaccum, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, int N, dict opts) -> Function\n"
		"  mapaccum(self, str name, int N, dict opts) -> Function\n"
		"  mapaccum(self, str name, int N, int n_accum, dict opts) -> Function\n"
		"  mapaccum(self, str name, int n, [str] accum_in, [str] accum_out, dict opts) -> Function\n"
		"  mapaccum(self, str name, int n, [int] accum_in, [int] accum_out, dict opts) -> Function\n"
		"\n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L693\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L626-L634\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, int N, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L697\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L515-L517\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, str name, int N, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L686\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L518-L520\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, str name, int N, int n_accum, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L687\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L521-L549\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, str name, int n, [str] accum_in, [str] accum_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L693\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L626-L634\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mapaccum(self, str name, int n, [int] accum_in, [int] accum_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L689\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L596-L624\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_fold", _wrap_Function_fold, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  fold(self, int N, dict opts) -> Function\n"
		"\n"
		"Create a mapaccumulated version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (x, u) -> (x_next , y )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapaccumulated version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (x0, U) -> (X , Y )\n"
		"\n"
		"      with\n"
		"          U: horzcat([u0, u1, ..., u_(N-1)])\n"
		"          X: horzcat([x1, x2, ..., x_N])\n"
		"          Y: horzcat([y0, y1, ..., y_(N-1)])\n"
		"\n"
		"      and\n"
		"          x1, y0 <- f(x0, u0)\n"
		"          x2, y1 <- f(x1, u1)\n"
		"          ...\n"
		"          x_N, y_(N-1) <- f(x_(N-1), u_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Mapaccum has the following benefits over writing an equivalent for-\n"
		"loop:\n"
		"\n"
		"much faster at construction time\n"
		"\n"
		"potentially much faster compilation times (for codegen)\n"
		"\n"
		"offers a trade-off between memory and evaluation time\n"
		"\n"
		"The base (settable through the options dictionary, default 10), is \n"
		"used to \n"
		"create a tower of function calls, containing unrolled for-\n"
		"loops of length \n"
		"maximum base.\n"
		"\n"
		"This technique is much more scalable in terms of memory-usage, but \n"
		"slightly\n"
		" slower at evaluation, than a plain for-loop. The effect is \n"
		"similar to that\n"
		" of a for-loop with a check-pointing instruction after \n"
		"each chunk of \n"
		"iterations with size base.\n"
		"\n"
		"Set base to -1 to unroll all the way; no gains in memory efficiency \n"
		"here.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L698\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L508-L514\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_map", _wrap_Function_map, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  map(self, int n, str parallelization) -> Function\n"
		"  map(self, int n, [bool] reduce_in, [bool] reduce_out, dict opts) -> Function\n"
		"  map(self, int n, str parallelization, int max_num_threads) -> Function\n"
		"  map(self, str name, str parallelization, int n, [str] reduce_in, [str] reduce_out, dict opts) -> Function\n"
		"  map(self, str name, str parallelization, int n, [int] reduce_in, [int] reduce_out, dict opts) -> Function\n"
		"\n"
		"Map with reduction.\n"
		"\n"
		"A subset of the inputs are non-repeated and a subset of the outputs \n"
		"summed \n"
		"up.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L741\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L667-L674\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  map(self, int n, [bool] reduce_in, [bool] reduce_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Map with reduction.\n"
		"\n"
		"A subset of the inputs are non-repeated and a subset of the outputs \n"
		"summed \n"
		"up.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L745\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L636-L642\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  map(self, str name, str parallelization, int n, [str] reduce_in, [str] reduce_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Map with reduction.\n"
		"\n"
		"A subset of the inputs are non-repeated and a subset of the outputs \n"
		"summed \n"
		"up.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L741\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L667-L674\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  map(self, str name, str parallelization, int n, [int] reduce_in, [int] reduce_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Map with reduction.\n"
		"\n"
		"A subset of the inputs are non-repeated and a subset of the outputs \n"
		"summed \n"
		"up.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L737\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L644-L665\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  map(self, int n, str parallelization, int max_num_threads)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  map(self, int n, str parallelization)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a mapped version of this function.\n"
		"\n"
		"Suppose the function has a signature of:\n"
		"\n"
		"::\n"
		"\n"
		"     f: (a, p) -> ( s )\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"The the mapped version has the signature:\n"
		"\n"
		"::\n"
		"\n"
		"     F: (A, P) -> (S )\n"
		"\n"
		"      with\n"
		"          A: horzcat([a0, a1, ..., a_(N-1)])\n"
		"          P: horzcat([p0, p1, ..., p_(N-1)])\n"
		"          S: horzcat([s0, s1, ..., s_(N-1)])\n"
		"      and\n"
		"          s0 <- f(a0, p0)\n"
		"          s1 <- f(a1, p1)\n"
		"          ...\n"
		"          s_(N-1) <- f(a_(N-1), p_(N-1))\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"parallelization: \n"
		"Type of parallelization used: unroll|serial|openmp\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L726\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L708-L743\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_slice", _wrap_Function_slice, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  slice(self, str name, [int] order_in, [int] order_out, dict opts) -> Function\n"
		"\n"
		"returns a new function with a selection of inputs/outputs of the\n"
		"\n"
		"original\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L754\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L746-L753\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_conditional", _wrap_Function_conditional, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  conditional(str name, Function f, dict opts) -> Function\n"
		"  conditional(str name, [Function] f, Function f_def, dict opts) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_bspline", _wrap_Function_bspline, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  bspline(str name, [[float]] knots, [float] coeffs, [int] degree, int m, dict opts) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_if_else", _wrap_Function_if_else, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  if_else(str name, Function f_true, Function f_false, dict opts) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_forward", _wrap_Function_forward, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  forward(self, int nfwd) -> Function\n"
		"\n"
		"Get a function that calculates  nfwd forward derivatives.\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"     Returns a function with <tt>n_in + n_out + n_in</tt> inputs\n"
		"     and <tt>nfwd</tt> outputs.\n"
		"     The first <tt>n_in</tt> inputs correspond to nondifferentiated inputs.\n"
		"     The next <tt>n_out</tt> inputs correspond to nondifferentiated outputs.\n"
		"     and the last <tt>n_in</tt> inputs correspond to forward seeds,\n"
		"     stacked horizontally\n"
		"     The  <tt>n_out</tt> outputs correspond to forward sensitivities,\n"
		"     stacked horizontally.     *\n"
		"     <tt>(n_in = n_in(), n_out = n_out())</tt>\n"
		"\n"
		"    The functions returned are cached, meaning that if called multiple timed\n"
		"    with the same value, then multiple references to the same function will be returned.\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L800\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1110-L1116\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_reverse", _wrap_Function_reverse, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reverse(self, int nadj) -> Function\n"
		"\n"
		"Get a function that calculates  nadj adjoint derivatives.\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"     Returns a function with <tt>n_in + n_out + n_out</tt> inputs\n"
		"     and <tt>n_in</tt> outputs.\n"
		"     The first <tt>n_in</tt> inputs correspond to nondifferentiated inputs.\n"
		"     The next <tt>n_out</tt> inputs correspond to nondifferentiated outputs.\n"
		"     and the last <tt>n_out</tt> inputs correspond to adjoint seeds,\n"
		"     stacked horizontally\n"
		"     The  <tt>n_in</tt> outputs correspond to adjoint sensitivities,\n"
		"     stacked horizontally.     *\n"
		"     <tt>(n_in = n_in(), n_out = n_out())</tt>\n"
		"\n"
		"     <tt>(n_in = n_in(), n_out = n_out())</tt>\n"
		"\n"
		"    The functions returned are cached, meaning that if called multiple timed\n"
		"    with the same value, then multiple references to the same function will be returned.\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L820\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1118-L1124\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_jac_sparsity", _wrap_Function_jac_sparsity, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  jac_sparsity(self, bool compact) -> [Sparsity]\n"
		"  jac_sparsity(self, int oind, int iind, bool compact) -> Sparsity\n"
		"\n"
		"Get, if necessary generate, the sparsity of all Jacobian blocks.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ws\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L825\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L931-L940\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  jac_sparsity(self, bool compact)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get, if necessary generate, the sparsity of all Jacobian blocks.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ws\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L825\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L931-L940\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  jac_sparsity(self, int oind, int iind, bool compact)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get, if necessary generate, the sparsity of a single Jacobian \n"
		"block.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L830\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L942-L948\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_generate", _wrap_Function_generate, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate(self, dict opts) -> str\n"
		"  generate(self, str fname, dict opts) -> str\n"
		"\n"
		"Export / Generate C code for the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L835\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1167-L1171\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate(self, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export / Generate C code for the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L840\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1163-L1165\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate(self, str fname, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export / Generate C code for the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L835\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1167-L1171\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_generate_dependencies", _wrap_Function_generate_dependencies, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate_dependencies(self, str fname, dict opts) -> str\n"
		"\n"
		"Export / Generate C code for the dependency function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ww\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L845\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1173-L1175\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_generate_in", _wrap_Function_generate_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate_in(self, str fname) -> [DM]\n"
		"  generate_in(self, str fname, [DM] arg)\n"
		"\n"
		"Export an input file that can be passed to generate C code with \n"
		"a \n"
		"main.\n"
		"\n"
		"See: \n"
		" generate_out\n"
		"\n"
		"See: \n"
		" convert_in to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L854\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1177-L1190\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate_in(self, str fname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export an input file that can be passed to generate C code with \n"
		"a \n"
		"main.\n"
		"\n"
		"See: \n"
		" generate_out\n"
		"\n"
		"See: \n"
		" convert_in to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L855\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1207-L1217\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate_in(self, str fname, [DM] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export an input file that can be passed to generate C code with \n"
		"a \n"
		"main.\n"
		"\n"
		"See: \n"
		" generate_out\n"
		"\n"
		"See: \n"
		" convert_in to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L854\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1177-L1190\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_generate_out", _wrap_Function_generate_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate_out(self, str fname) -> [DM]\n"
		"  generate_out(self, str fname, [DM] arg)\n"
		"\n"
		"Export an output file that can be checked with generated C code\n"
		"\n"
		"output.\n"
		"\n"
		"See: \n"
		" generate_in\n"
		"\n"
		"See: \n"
		" convert_out to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L865\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1192-L1205\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate_out(self, str fname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export an output file that can be checked with generated C code\n"
		"\n"
		"output.\n"
		"\n"
		"See: \n"
		" generate_in\n"
		"\n"
		"See: \n"
		" convert_out to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L866\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1219-L1229\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  generate_out(self, str fname, [DM] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export an output file that can be checked with generated C code\n"
		"\n"
		"output.\n"
		"\n"
		"See: \n"
		" generate_in\n"
		"\n"
		"See: \n"
		" convert_out to convert between dict/map and vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L865\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1192-L1205\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_serialize", _wrap_Function_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, dict opts) -> str\n"
		"\n"
		"Serialize.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L893\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1248-L1252\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_save", _wrap_Function_save, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  save(self, str fname, dict opts)\n"
		"\n"
		"Save  Function to a file.\n"
		"\n"
		"See: \n"
		" load\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_240\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L900\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1243-L1246\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_export_code", _wrap_Function_export_code, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, dict options) -> str\n"
		"  export_code(self, str lang, str fname, dict options)\n"
		"\n"
		"Export function in specific language.\n"
		"\n"
		"Only allowed for (a subset of) SX/MX Functions\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L875\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1236-L1240\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, dict options)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export function in specific language.\n"
		"\n"
		"Only allowed for (a subset of) SX/MX Functions\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L902\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1275-L1279\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  export_code(self, str lang, str fname, dict options)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Export function in specific language.\n"
		"\n"
		"Only allowed for (a subset of) SX/MX Functions\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1wz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L875\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1236-L1240\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_stats", _wrap_Function_stats, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  stats(self, int mem) -> dict\n"
		"\n"
		"Get all statistics obtained at the end of the last evaluate \n"
		"call.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L932\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L927-L929\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sx_in", _wrap_Function_sx_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sx_in(self) -> [SX]\n"
		"  sx_in(self, int iind) -> SX\n"
		"  sx_in(self, str iname) -> SX\n"
		"\n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L941\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L941-L943\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L944\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1542-L1548\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_in(self, int iind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L940\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1526-L1532\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L941\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L941-L943\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_mx_in", _wrap_Function_mx_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mx_in(self) -> [MX]\n"
		"  mx_in(self, int ind) -> MX\n"
		"  mx_in(self, str iname) -> MX\n"
		"\n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L946\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L946-L948\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_in(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L949\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1566-L1568\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_in(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L945\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1558-L1560\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_in(self, str iname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the input expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L946\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L946-L948\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sx_out", _wrap_Function_sx_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sx_out(self) -> [SX]\n"
		"  sx_out(self, int oind) -> SX\n"
		"  sx_out(self, str oname) -> SX\n"
		"\n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L959\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L959-L961\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L962\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1550-L1556\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_out(self, int oind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L958\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1534-L1540\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  sx_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L959\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L959-L961\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_mx_out", _wrap_Function_mx_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mx_out(self) -> [MX]\n"
		"  mx_out(self, int ind) -> MX\n"
		"  mx_out(self, str oname) -> MX\n"
		"\n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L964\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L964-L966\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_out(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L967\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1570-L1572\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_out(self, int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L963\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1562-L1564\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  mx_out(self, str oname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbolic primitives equivalent to the output expressions.\n"
		"\n"
		"There is no guarantee that subsequent calls return unique answers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L964\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L964-L966\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nz_from_in", _wrap_Function_nz_from_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nz_from_in(self, [DM] arg) -> [float]\n"
		"\n"
		"Convert from/to flat vector of input/output nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L974\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1574-L1576\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nz_from_out", _wrap_Function_nz_from_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nz_from_out(self, [DM] arg) -> [float]\n"
		"\n"
		"Convert from/to flat vector of input/output nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L975\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1578-L1580\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nz_to_in", _wrap_Function_nz_to_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nz_to_in(self, [float] arg) -> [DM]\n"
		"\n"
		"Convert from/to flat vector of input/output nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L976\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1582-L1584\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_nz_to_out", _wrap_Function_nz_to_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nz_to_out(self, [float] arg) -> [DM]\n"
		"\n"
		"Convert from/to flat vector of input/output nonzeros.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L977\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1586-L1588\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_convert_in", _wrap_Function_convert_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, dict:DM arg) -> [DM]\n"
		"  convert_in(self, [DM] arg) -> dict:DM\n"
		"  convert_in(self, [SX] arg) -> dict:SX\n"
		"  convert_in(self, dict:SX arg) -> [SX]\n"
		"  convert_in(self, dict:MX arg) -> [MX]\n"
		"  convert_in(self, [MX] arg) -> dict:MX\n"
		"\n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L995\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1622-L1624\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, dict:DM arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L988\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1594-L1596\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, [DM] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L987\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1590-L1592\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, [SX] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L991\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1606-L1608\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, dict:SX arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L992\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1610-L1612\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, dict:MX arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L996\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1626-L1628\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_in(self, [MX] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L995\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1622-L1624\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_convert_out", _wrap_Function_convert_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, dict:DM arg) -> [DM]\n"
		"  convert_out(self, [DM] arg) -> dict:DM\n"
		"  convert_out(self, [SX] arg) -> dict:SX\n"
		"  convert_out(self, dict:SX arg) -> [SX]\n"
		"  convert_out(self, dict:MX arg) -> [MX]\n"
		"  convert_out(self, [MX] arg) -> dict:MX\n"
		"\n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L997\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1630-L1632\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, dict:DM arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L990\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1602-L1604\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, [DM] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L989\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1598-L1600\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, [SX] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L993\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1614-L1616\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, dict:SX arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L994\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1618-L1620\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, dict:MX arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L998\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1634-L1636\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  convert_out(self, [MX] arg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Convert from/to input/output lists/map.\n"
		"\n"
		"Will raise an error when an unknown key is used or a list has \n"
		"incorrect \n"
		"size. Does not perform sparsity checking.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L997\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1630-L1632\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_has_free", (PyCFunction)_wrap_Function_has_free, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_free(self) -> bool\n"
		"\n"
		"Does the function have free variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1004\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1666-L1668\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_get_free", (PyCFunction)_wrap_Function_get_free, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_free(self) -> [str]\n"
		"\n"
		"Get free variables as a string.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1x9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1009\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1159-L1161\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_free_sx", (PyCFunction)_wrap_Function_free_sx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  free_sx(self) -> [SX]\n"
		"\n"
		"Get all the free variables of the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xa\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1014\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1642-L1648\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_free_mx", (PyCFunction)_wrap_Function_free_mx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  free_mx(self) -> [MX]\n"
		"\n"
		"Get all the free variables of the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1019\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1650-L1656\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_generate_lifted", (PyCFunction)_wrap_Function_generate_lifted, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate_lifted(self) -> (Function OUTPUT, Function OUTPUT)\n"
		"\n"
		"Extract the functions needed for the Lifted  Newton method.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1024\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1670-L1676\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_n_nodes", (PyCFunction)_wrap_Function_n_nodes, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_nodes(self) -> int\n"
		"\n"
		"Number of nodes in the algorithm.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1030\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1734-L1740\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_n_instructions", (PyCFunction)_wrap_Function_n_instructions, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  n_instructions(self) -> int\n"
		"\n"
		"Number of instruction in the algorithm (SXFunction/MXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xe\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1035\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1678-L1684\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instruction_id", _wrap_Function_instruction_id, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instruction_id(self, int k) -> int\n"
		"\n"
		"Identifier index of the instruction (SXFunction/MXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1040\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1702-L1708\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instruction_input", _wrap_Function_instruction_input, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instruction_input(self, int k) -> [int]\n"
		"\n"
		"Locations in the work vector for the inputs of the instruction.\n"
		"\n"
		"(SXFunction/MXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1047\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1710-L1716\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instruction_constant", _wrap_Function_instruction_constant, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instruction_constant(self, int k) -> float\n"
		"\n"
		"Get the floating point output argument of an instruction \n"
		"(SXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1052\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1718-L1724\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instruction_output", _wrap_Function_instruction_output, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instruction_output(self, int k) -> [int]\n"
		"\n"
		"Location in the work vector for the output of the instruction.\n"
		"\n"
		"(SXFunction/MXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1059\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1726-L1732\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instruction_MX", _wrap_Function_instruction_MX, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instruction_MX(self, int k) -> MX\n"
		"\n"
		"Get the  MX node corresponding to an instruction (MXFunction)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1064\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1686-L1692\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_instructions_sx", (PyCFunction)_wrap_Function_instructions_sx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instructions_sx(self) -> SX\n"
		"\n"
		"Get the SX node corresponding to all instructions (SXFunction)\n"
		"\n"
		"Note: input and output instructions have no SX representation. This \n"
		"method \n"
		"returns nan for those instructions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1072\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1694-L1700\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_has_spfwd", (PyCFunction)_wrap_Function_has_spfwd, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_spfwd(self) -> bool\n"
		"\n"
		"Is the class able to propagate seeds through the algorithm?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1078\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1658-L1660\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_has_sprev", (PyCFunction)_wrap_Function_has_sprev, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_sprev(self) -> bool\n"
		"\n"
		"Is the class able to propagate seeds through the algorithm?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1079\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1662-L1664\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sz_arg", (PyCFunction)_wrap_Function_sz_arg, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sz_arg(self) -> size_t\n"
		"\n"
		"Get required length of arg field.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1085\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1058-L1058\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sz_res", (PyCFunction)_wrap_Function_sz_res, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sz_res(self) -> size_t\n"
		"\n"
		"Get required length of res field.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1090\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1060-L1060\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sz_iw", (PyCFunction)_wrap_Function_sz_iw, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sz_iw(self) -> size_t\n"
		"\n"
		"Get required length of iw field.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xo\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1095\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1062-L1062\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_sz_w", (PyCFunction)_wrap_Function_sz_w, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sz_w(self) -> size_t\n"
		"\n"
		"Get required length of w field.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1100\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1064-L1064\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_name", (PyCFunction)_wrap_Function_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  name(self) -> str\n"
		"\n"
		"Name of the function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1137\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1281-L1288\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_is_a", _wrap_Function_is_a, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_a(self, str type, bool recursive) -> bool\n"
		"\n"
		"Check if the function is of a particular type.\n"
		"\n"
		"Optionally check if name matches one of the base classes (default \n"
		"true)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1xw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1144\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1638-L1640\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_check_name", (PyCFunction)_wrap_Function_check_name, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  check_name(str name) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_fix_name", (PyCFunction)_wrap_Function_fix_name, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  fix_name(str name) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_load", (PyCFunction)_wrap_Function_load, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  load(str filename) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_deserialize", _wrap_Function_deserialize, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(std::istream & stream) -> Function\n"
		"  deserialize(casadi::DeserializingStream & s) -> Function\n"
		"  deserialize(str s) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_assert_size_in", _wrap_Function_assert_size_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_size_in(self, int i, int nrow, int ncol)\n"
		"\n"
		"Assert that an input dimension is equal so some given value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1754-L1760\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_assert_size_out", _wrap_Function_assert_size_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_size_out(self, int i, int nrow, int ncol)\n"
		"\n"
		"Assert that an output dimension is equal so some given value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1192\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1762-L1767\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_assert_sparsity_out", _wrap_Function_assert_sparsity_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_sparsity_out(self, int i, Sparsity sp, int n, bool allow_all_zero_sparse)\n"
		"\n"
		"Assert that an output sparsity is a multiple of some given \n"
		"sparsity.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1195\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1769-L1778\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_checkout", (PyCFunction)_wrap_Function_checkout, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  checkout(self) -> int\n"
		"\n"
		"Checkout a memory object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1199\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1742-L1744\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_release", _wrap_Function_release, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  release(self, int mem)\n"
		"\n"
		"Release a memory object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1202\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1746-L1748\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_cache", (PyCFunction)_wrap_Function_cache, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  cache(self) -> dict\n"
		"\n"
		"Get all functions in the cache.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26i\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1212\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1804-L1811\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_get_function", _wrap_Function_get_function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_function(self) -> [str]\n"
		"  get_function(self, str name) -> Function\n"
		"\n"
		"Get a list of all functions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1217\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1813-L1820\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_function(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a dependency function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1222\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1822-L1828\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get_function(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get a list of all functions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1217\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1813-L1820\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_has_function", _wrap_Function_has_function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_function(self, str fname) -> bool\n"
		"\n"
		"Check if a particular dependency exists.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1227\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1830-L1837\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_find_functions", _wrap_Function_find_functions, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  find_functions(self, int max_depth) -> [Function]\n"
		"\n"
		"Get all functions embedded in the expression graphs.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_depth: \n"
		"Maximum depth - a negative number indicates no maximum\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1234\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1839-L1855\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_find_function", _wrap_Function_find_function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  find_function(self, str name, int max_depth) -> Function\n"
		"\n"
		"Get a specific function embedded in the expression graphs.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of function needed\n"
		"\n"
		"max_depth: \n"
		"Maximum depth - a negative number indicates no maximum\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1y7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1242\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1857-L1874\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_info", (PyCFunction)_wrap_Function_info, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  info(self) -> dict\n"
		"\n"
		"Obtain information about function\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1245\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1903-L1905\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Function", _wrap_new_Function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Function()\n"
		"  Function(str fname)\n"
		"  Function(Function other)\n"
		"  Function(str name, [SX] ex_in, [SX] ex_out, dict opts)\n"
		"  Function(str name, [MX] ex_in, [MX] ex_out, dict opts)\n"
		"  Function(str name, dict:SX dict, [str] name_in, [str] name_out, dict opts)\n"
		"  Function(str name, dict:MX dict, [str] name_in, [str] name_out, dict opts)\n"
		"  Function(str name, [SX] ex_in, [SX] ex_out, [str] name_in, [str] name_out, dict opts)\n"
		"  Function(str name, [MX] ex_in, [MX] ex_out, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"Construct an  MX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L111\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L188-L192\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(Function other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, [MX] ex_in, [MX] ex_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an  MX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L101\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L109-L113\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, dict:MX dict, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an  MX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L111\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L188-L192\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, [MX] ex_in, [MX] ex_out, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an  MX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L105\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L115-L121\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor, null pointer.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1uy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L70\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L57-L58\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, [SX] ex_in, [SX] ex_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an SX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L81\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L95-L99\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, dict:SX dict, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an SX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L91\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L182-L186\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str name, [SX] ex_in, [SX] ex_out, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct an SX function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1v0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L85\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L101-L107\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Function(str fname)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct from a file.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1uz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L75\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L91-L93\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Function_swigregister", Function_swigregister, METH_VARARGS, NULL},
	 { (char *)"FunctionBuffer_set_arg", _wrap_FunctionBuffer_set_arg, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_arg(self, int i, memoryview(ro) a, casadi_int size)\n"
		"\n"
		"Set input buffer for input i.\n"
		"\n"
		"mem.set_arg(0, memoryview(a))\n"
		"\n"
		"Note that CasADi uses 'fortran' order: column-by-column\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1yb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1323\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1943-L1948\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FunctionBuffer_set_res", _wrap_FunctionBuffer_set_res, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_res(self, int i, memoryview(rw) a, casadi_int size)\n"
		"\n"
		"Set output buffer for ouput i.\n"
		"\n"
		"mem.set_res(0, memoryview(a))\n"
		"\n"
		"Note that CasADi uses 'fortran' order: column-by-column\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1yc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1332\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1949-L1954\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FunctionBuffer_ret", (PyCFunction)_wrap_FunctionBuffer_ret, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ret(self) -> int\n"
		"\n"
		"Get last return value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1334\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1962-L1964\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FunctionBuffer__eval", (PyCFunction)_wrap_FunctionBuffer__eval, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _eval(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FunctionBuffer__self", (PyCFunction)_wrap_FunctionBuffer__self, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _self(self) -> void*\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_FunctionBuffer", _wrap_new_FunctionBuffer, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FunctionBuffer(FunctionBuffer other)\n"
		"  FunctionBuffer(Function f)\n"
		"\n"
		"Main constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ya\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1309\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1907-L1915\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  FunctionBuffer(FunctionBuffer other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  FunctionBuffer(Function f)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Main constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ya\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.hpp#L1309\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/function.cpp#L1907-L1915\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_FunctionBuffer", (PyCFunction)_wrap_delete_FunctionBuffer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FunctionBuffer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FunctionBuffer_swigregister", FunctionBuffer_swigregister, METH_VARARGS, NULL},
	 { (char *)"_function_buffer_eval", (PyCFunction)_wrap__function_buffer_eval, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  _function_buffer_eval(void* raw)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"external", _wrap_external, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  external(str name, dict opts) -> Function\n"
		"  external(str name, Importer li, dict opts) -> Function\n"
		"  external(str name, str bin_name, dict opts) -> Function\n"
		"\n"
		"Load an external function from a shared library.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name as in the label assigned to a CasADi  Function object: \n"
		"Function(name,...,...) Will be used to look up \n"
		"symbols/functions named eg. \n"
		"<name>_eval Use  nm (linux/osx) or  depends.exe (win) to check which symbols\n"
		" are present in your shared library\n"
		"\n"
		"bin_name: \n"
		"File name of the shared library\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_i1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.hpp#L51\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.cpp#L51-L54\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  external(str name, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Load an external function from a shared library.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name as in the label assigned to a CasADi  Function object: \n"
		"Function(name,...,...) Will be used to look up \n"
		"symbols/functions named eg. \n"
		"<name>_eval Use  nm (linux/osx) or  depends.exe (win) to check which symbols\n"
		" are present in your shared library\n"
		"\n"
		"File name is assumed to be ./<name>.so\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_i0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.hpp#L47\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.cpp#L47-L49\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  external(str name, str bin_name, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Load an external function from a shared library.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name as in the label assigned to a CasADi  Function object: \n"
		"Function(name,...,...) Will be used to look up \n"
		"symbols/functions named eg. \n"
		"<name>_eval Use  nm (linux/osx) or  depends.exe (win) to check which symbols\n"
		" are present in your shared library\n"
		"\n"
		"bin_name: \n"
		"File name of the shared library\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_i1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.hpp#L51\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.cpp#L51-L54\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  external(str name, Importer li, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Load a just-in-time compiled external function.\n"
		"\n"
		"File name given\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_i2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.hpp#L42\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/external.cpp#L42-L45\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"integrator", _wrap_integrator, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  integrator(str name, str solver, dict:SX dae, dict opts) -> Function\n"
		"  integrator(str name, str solver, dict:MX dae, dict opts) -> Function\n"
		"  integrator(str name, str solver, Function dae, dict opts) -> Function\n"
		"  integrator(str name, str solver, dict:SX dae, float t0, [float] tout, dict opts) -> Function\n"
		"  integrator(str name, str solver, dict:SX dae, float t0, float tf, dict opts) -> Function\n"
		"  integrator(str name, str solver, dict:MX dae, float t0, [float] tout, dict opts) -> Function\n"
		"  integrator(str name, str solver, dict:MX dae, float t0, float tf, dict opts) -> Function\n"
		"  integrator(str name, str solver, Function dae, float t0, [float] tout, dict opts) -> Function\n"
		"  integrator(str name, str solver, Function dae, float t0, float tf, dict opts) -> Function\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator(str name, str solver, dict:SX dae, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Create an ODE/DAE integrator Solves an initial value problem (IVP) \n"
		"coupled \n"
		"to a terminal value problem with differential equation given \n"
		"as an implicit\n"
		" ODE coupled to an algebraic equation and a set of \n"
		"quadratures:\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Initial conditions at t=t0\n"
		"  x(t0)  = x0\n"
		"  q(t0)  = 0\n"
		"\n"
		"  Forward integration from t=t0 to t=tf\n"
		"  der(x) = function(x, z, p, t)                  Forward ODE\n"
		"  0 = fz(x, z, p, t)                  Forward algebraic equations\n"
		"  der(q) = fq(x, z, p, t)                  Forward quadratures\n"
		"\n"
		"  Terminal conditions at t=tf\n"
		"  rx(tf)  = rx0\n"
		"  rq(tf)  = 0\n"
		"\n"
		"  Backward integration from t=tf to t=t0\n"
		"  der(rx) = gx(rx, rz, rp, x, z, p, t)        Backward ODE\n"
		"  0 = gz(rx, rz, rp, x, z, p, t)        Backward algebraic equations\n"
		"  der(rq) = gq(rx, rz, rp, x, z, p, t)        Backward quadratures\n"
		"\n"
		"  where we assume that both the forward and backwards integrations are index-1\n"
		"  (i.e. dfz/dz, dgz/drz are invertible) and furthermore that\n"
		"  gx, gz and gq have a linear dependency on rx, rz and rp.\n"
		"\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| augmented_option | OT_DICT         | Options to be    | casadi::Integrat |\n"
		"| s                |                 | passed down to   | or               |\n"
		"|                  |                 | the augmented    |                  |\n"
		"|                  |                 | integrator, if   |                  |\n"
		"|                  |                 | one is           |                  |\n"
		"|                  |                 | constructed.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| common_options   | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | auto-generated   | nction           |\n"
		"|                  |                 | functions        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| expand           | OT_BOOL         | Replace MX with  | casadi::Integrat |\n"
		"|                  |                 | SX expressions   | or               |\n"
		"|                  |                 | in problem       |                  |\n"
		"|                  |                 | formulation      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| grid             | OT_DOUBLEVECTOR | [DEPRECATED]     | casadi::Integrat |\n"
		"|                  |                 | Time grid        | or               |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |\n"
		"|                  |                 | problem          | nction           |\n"
		"|                  |                 | functions to be  |                  |\n"
		"|                  |                 | monitored        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| nadj             | OT_INT          | Number of        | casadi::Integrat |\n"
		"|                  |                 | adjoint          | or               |\n"
		"|                  |                 | sensitivities to |                  |\n"
		"|                  |                 | be calculated    |                  |\n"
		"|                  |                 | [0]              |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| nfwd             | OT_INT          | Number of        | casadi::Integrat |\n"
		"|                  |                 | forward          | or               |\n"
		"|                  |                 | sensitivities to |                  |\n"
		"|                  |                 | be calculated    |                  |\n"
		"|                  |                 | [0]              |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| number_of_finite | OT_INT          | Target number of | casadi::Integrat |\n"
		"| _elements        |                 | finite elements. | or               |\n"
		"|                  |                 | The actual       |                  |\n"
		"|                  |                 | number may be    |                  |\n"
		"|                  |                 | higher to        |                  |\n"
		"|                  |                 | accommodate all  |                  |\n"
		"|                  |                 | output times     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_t0        | OT_BOOL         | [DEPRECATED]     | casadi::Integrat |\n"
		"|                  |                 | Output the state | or               |\n"
		"|                  |                 | at the initial   |                  |\n"
		"|                  |                 | time             |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_stats      | OT_BOOL         | Print out        | casadi::Integrat |\n"
		"|                  |                 | statistics after | or               |\n"
		"|                  |                 | integration      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| rootfinder       | OT_STRING       | An implicit      | casadi::Integrat |\n"
		"|                  |                 | function solver  | or               |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| rootfinder_optio | OT_DICT         | Options to be    | casadi::Integrat |\n"
		"| ns               |                 | passed to the    | or               |\n"
		"|                  |                 | NLP Solver       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |\n"
		"| gs               |                 | generated from   | nction           |\n"
		"|                  |                 | function         |                  |\n"
		"|                  |                 | evaluations      |                  |\n"
		"|                  |                 | [true]           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| simplify         | OT_BOOL         | Implement as MX  | casadi::Integrat |\n"
		"|                  |                 | Function (codege | or               |\n"
		"|                  |                 | neratable/serial |                  |\n"
		"|                  |                 | izable) default: |                  |\n"
		"|                  |                 | false            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| simplify_options | OT_DICT         | Any options to   | casadi::Integrat |\n"
		"|                  |                 | pass to          | or               |\n"
		"|                  |                 | simplified form  |                  |\n"
		"|                  |                 | Function         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| specific_options | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | specific auto-   | nction           |\n"
		"|                  |                 | generated        |                  |\n"
		"|                  |                 | functions,       |                  |\n"
		"|                  |                 | overwriting the  |                  |\n"
		"|                  |                 | defaults from    |                  |\n"
		"|                  |                 | common_options.  |                  |\n"
		"|                  |                 | Nested           |                  |\n"
		"|                  |                 | dictionary.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| t0               | OT_DOUBLE       | [DEPRECATED]     | casadi::Integrat |\n"
		"|                  |                 | Beginning of the | or               |\n"
		"|                  |                 | time horizon     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| tf               | OT_DOUBLE       | [DEPRECATED] End | casadi::Integrat |\n"
		"|                  |                 | of the time      | or               |\n"
		"|                  |                 | horizon          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		">Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 7)\n"
		"\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"|     Full name     | Short  |                 Description                 |\n"
		"+===================+========+=============================================+\n"
		"| INTEGRATOR_X0     | x0     | Differential state at the initial time.     |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_Z0     | z0     | Initial guess for the algebraic variable at |\n"
		"|                   |        | the initial time.                           |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_P      | p      | Parameters.                                 |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_U      | u      | Piecewise constant control, a new control   |\n"
		"|                   |        | interval starts at each output time.        |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_XF | adj_xf | Adjoint seeds corresponding to the states   |\n"
		"|                   |        | at the output times.                        |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_ZF | adj_zf | Adjoint seeds corresponding to the          |\n"
		"|                   |        | algebraic variables at the output times.    |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_QF | adj_qf | Adjoint seeds corresponding to the          |\n"
		"|                   |        | quadratures at the output times.            |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"\n"
		">Output scheme: casadi::IntegratorOutput (INTEGRATOR_NUM_OUT = 7)\n"
		"\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"|     Full name     | Short  |                 Description                 |\n"
		"+===================+========+=============================================+\n"
		"| INTEGRATOR_XF     | xf     | Differential state at all output times.     |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ZF     | zf     | Algebraic variable at all output times.     |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_QF     | qf     | Quadrature state at all output times.       |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_X0 | adj_x0 | Adjoint sensitivities corresponding to the  |\n"
		"|                   |        | initial state.                              |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_Z0 | adj_z0 | Adjoint sensitivities corresponding to the  |\n"
		"|                   |        | algebraic variable guess.                   |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_P  | adj_p  | Adjoint sensitivities corresponding to the  |\n"
		"|                   |        | parameter vector.                           |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"| INTEGRATOR_ADJ_U  | adj_u  | Adjoint sensitivities corresponding to the  |\n"
		"|                   |        | control vector.                             |\n"
		"+-------------------+--------+---------------------------------------------+\n"
		"\n"
		"List of plugins\n"
		"- cvodes\n"
		"\n"
		"- idas\n"
		"\n"
		"- collocation\n"
		"\n"
		"- rk\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Integrator.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"cvodes\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Interface to CVodes from the Sundials suite.\n"
		"\n"
		"A call to evaluate will integrate to the end.\n"
		"\n"
		"You can retrieve the entire state trajectory as follows, after the \n"
		"evaluate\n"
		" call: Call reset. Then call integrate(t_i) and getOuput for a\n"
		" series of \n"
		"times t_i.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_228\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"|             Id              |   Type    |          Description           |\n"
		"+=============================+===========+================================+\n"
		"| abstol                      | OT_DOUBLE | Absolute tolerence for the IVP |\n"
		"|                             |           | solution                       |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| always_recalculate_jacobian | OT_BOOL   | Recalculate Jacobian before    |\n"
		"|                             |           | factorizations, even if        |\n"
		"|                             |           | Jacobian is current [default:  |\n"
		"|                             |           | true]                          |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| disable_internal_warnings   | OT_BOOL   | Disable SUNDIALS internal      |\n"
		"|                             |           | warning messages               |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| fsens_all_at_once           | OT_BOOL   | Calculate all right hand sides |\n"
		"|                             |           | of the sensitivity equations   |\n"
		"|                             |           | at once                        |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| fsens_err_con               | OT_BOOL   | include the forward            |\n"
		"|                             |           | sensitivities in all error     |\n"
		"|                             |           | controls                       |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| interpolation_type          | OT_STRING | Type of interpolation for the  |\n"
		"|                             |           | adjoint sensitivities          |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| linear_multistep_method     | OT_STRING | Integrator scheme: BDF|adams   |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| linear_solver               | OT_STRING | A custom linear solver creator |\n"
		"|                             |           | function [default: qr]         |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| linear_solver_options       | OT_DICT   | Options to be passed to the    |\n"
		"|                             |           | linear solver                  |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| max_krylov                  | OT_INT    | Maximum Krylov subspace size   |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| max_multistep_order         | OT_INT    | Maximum order for the          |\n"
		"|                             |           | (variable-order) multistep     |\n"
		"|                             |           | method                         |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| max_num_steps               | OT_INT    | Maximum number of integrator   |\n"
		"|                             |           | steps                          |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| max_order                   | OT_DOUBLE | Maximum order                  |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| max_step_size               | OT_DOUBLE | Max step size [default: 0/inf] |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| min_step_size               | OT_DOUBLE | Min step size [default: 0/0.0] |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| newton_scheme               | OT_STRING | Linear solver scheme in the    |\n"
		"|                             |           | Newton method:                 |\n"
		"|                             |           | DIRECT|gmres|bcgstab|tfqmr     |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| nonlin_conv_coeff           | OT_DOUBLE | Coefficient in the nonlinear   |\n"
		"|                             |           | convergence test               |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| nonlinear_solver_iteration  | OT_STRING | Nonlinear solver type:         |\n"
		"|                             |           | NEWTON|functional              |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| quad_err_con                | OT_BOOL   | Should the quadratures affect  |\n"
		"|                             |           | the step size control          |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| reltol                      | OT_DOUBLE | Relative tolerence for the IVP |\n"
		"|                             |           | solution                       |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| scale_abstol                | OT_BOOL   | Scale absolute tolerance by    |\n"
		"|                             |           | nominal value                  |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| second_order_correction     | OT_BOOL   | Second order correction in the |\n"
		"|                             |           | augmented system Jacobian      |\n"
		"|                             |           | [true]                         |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| sensitivity_method          | OT_STRING | Sensitivity method:            |\n"
		"|                             |           | SIMULTANEOUS|staggered         |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| step0                       | OT_DOUBLE | initial step size [default:    |\n"
		"|                             |           | 0/estimated]                   |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| steps_per_checkpoint        | OT_INT    | Number of steps between two    |\n"
		"|                             |           | consecutive checkpoints        |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| stop_at_end                 | OT_BOOL   | [DEPRECATED] Stop the          |\n"
		"|                             |           | integrator at the end of the   |\n"
		"|                             |           | interval                       |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"| use_preconditioner          | OT_BOOL   | Precondition the iterative     |\n"
		"|                             |           | solver [default: true]         |\n"
		"+-----------------------------+-----------+--------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"idas\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Interface to IDAS from the Sundials suite.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_225\n"
		"\n"
		">List of available options\n"
		"\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"|            Id             |      Type       |        Description         |\n"
		"+===========================+=================+============================+\n"
		"| abstol                    | OT_DOUBLE       | Absolute tolerence for the |\n"
		"|                           |                 | IVP solution               |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| abstolv                   | OT_DOUBLEVECTOR | Absolute tolerarance for   |\n"
		"|                           |                 | each component             |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| calc_ic                   | OT_BOOL         | Use IDACalcIC to get       |\n"
		"|                           |                 | consistent initial         |\n"
		"|                           |                 | conditions.                |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| calc_icB                  | OT_BOOL         | Use IDACalcIC to get       |\n"
		"|                           |                 | consistent initial         |\n"
		"|                           |                 | conditions for backwards   |\n"
		"|                           |                 | system [default: equal to  |\n"
		"|                           |                 | calc_ic].                  |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| cj_scaling                | OT_BOOL         | IDAS scaling on cj for the |\n"
		"|                           |                 | user-defined linear solver |\n"
		"|                           |                 | module                     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| constraints               | OT_INTVECTOR    | Constrain the solution     |\n"
		"|                           |                 | y=[x,z]. 0 (default): no   |\n"
		"|                           |                 | constraint on yi, 1: yi >= |\n"
		"|                           |                 | 0.0, -1: yi <= 0.0, 2: yi  |\n"
		"|                           |                 | > 0.0, -2: yi < 0.0.       |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| disable_internal_warnings | OT_BOOL         | Disable SUNDIALS internal  |\n"
		"|                           |                 | warning messages           |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| first_time                | OT_DOUBLE       | First requested time as a  |\n"
		"|                           |                 | fraction of the time       |\n"
		"|                           |                 | interval                   |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| fsens_err_con             | OT_BOOL         | include the forward        |\n"
		"|                           |                 | sensitivities in all error |\n"
		"|                           |                 | controls                   |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| init_xdot                 | OT_DOUBLEVECTOR | Initial values for the     |\n"
		"|                           |                 | state derivatives          |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| interpolation_type        | OT_STRING       | Type of interpolation for  |\n"
		"|                           |                 | the adjoint sensitivities  |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| linear_solver             | OT_STRING       | A custom linear solver     |\n"
		"|                           |                 | creator function [default: |\n"
		"|                           |                 | qr]                        |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| linear_solver_options     | OT_DICT         | Options to be passed to    |\n"
		"|                           |                 | the linear solver          |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_krylov                | OT_INT          | Maximum Krylov subspace    |\n"
		"|                           |                 | size                       |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_multistep_order       | OT_INT          | Maximum order for the      |\n"
		"|                           |                 | (variable-order) multistep |\n"
		"|                           |                 | method                     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_num_steps             | OT_INT          | Maximum number of          |\n"
		"|                           |                 | integrator steps           |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_order                 | OT_DOUBLE       | Maximum order              |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_step_size             | OT_DOUBLE       | Maximim step size          |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| newton_scheme             | OT_STRING       | Linear solver scheme in    |\n"
		"|                           |                 | the Newton method:         |\n"
		"|                           |                 | DIRECT|gmres|bcgstab|tfqmr |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| nonlin_conv_coeff         | OT_DOUBLE       | Coefficient in the         |\n"
		"|                           |                 | nonlinear convergence test |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| quad_err_con              | OT_BOOL         | Should the quadratures     |\n"
		"|                           |                 | affect the step size       |\n"
		"|                           |                 | control                    |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| reltol                    | OT_DOUBLE       | Relative tolerence for the |\n"
		"|                           |                 | IVP solution               |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| scale_abstol              | OT_BOOL         | Scale absolute tolerance   |\n"
		"|                           |                 | by nominal value           |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| second_order_correction   | OT_BOOL         | Second order correction in |\n"
		"|                           |                 | the augmented system       |\n"
		"|                           |                 | Jacobian [true]            |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| sensitivity_method        | OT_STRING       | Sensitivity method:        |\n"
		"|                           |                 | SIMULTANEOUS|staggered     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| step0                     | OT_DOUBLE       | initial step size          |\n"
		"|                           |                 | [default: 0/estimated]     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| steps_per_checkpoint      | OT_INT          | Number of steps between    |\n"
		"|                           |                 | two consecutive            |\n"
		"|                           |                 | checkpoints                |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| stop_at_end               | OT_BOOL         | [DEPRECATED] Stop the      |\n"
		"|                           |                 | integrator at the end of   |\n"
		"|                           |                 | the interval               |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| suppress_algebraic        | OT_BOOL         | Suppress algebraic         |\n"
		"|                           |                 | variables in the error     |\n"
		"|                           |                 | testing                    |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| use_preconditioner        | OT_BOOL         | Precondition the iterative |\n"
		"|                           |                 | solver [default: true]     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"collocation\n"
		"-----------\n"
		"\n"
		"\n"
		"\n"
		"Fixed-step implicit Runge-Kutta integrator ODE/DAE integrator based \n"
		"on \n"
		"collocation schemes\n"
		"\n"
		"The method is still under development\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_234\n"
		"\n"
		">List of available options\n"
		"\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"|            Id             |   Type    |           Description            |\n"
		"+===========================+===========+==================================+\n"
		"| collocation_scheme        | OT_STRING | Collocation scheme:              |\n"
		"|                           |           | radau|legendre                   |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| interpolation_order       | OT_INT    | Order of the interpolating       |\n"
		"|                           |           | polynomials                      |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| number_of_finite_elements | OT_INT    | Target number of finite          |\n"
		"|                           |           | elements. The actual number may  |\n"
		"|                           |           | be higher to accommodate all     |\n"
		"|                           |           | output times                     |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| rootfinder                | OT_STRING | An implicit function solver      |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| rootfinder_options        | OT_DICT   | Options to be passed to the NLP  |\n"
		"|                           |           | Solver                           |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| simplify                  | OT_BOOL   | Implement as MX  Function        |\n"
		"|                           |           | (codegeneratable/serializable)   |\n"
		"|                           |           | default: false                   |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"| simplify_options          | OT_DICT   | Any options to pass to           |\n"
		"|                           |           | simplified form Function         |\n"
		"|                           |           | constructor                      |\n"
		"+---------------------------+-----------+----------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"rk\n"
		"--\n"
		"\n"
		"\n"
		"\n"
		"Fixed-step explicit Runge-Kutta integrator for ODEs Currently \n"
		"implements \n"
		"RK4.\n"
		"\n"
		"The method is still under development\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23a\n"
		"\n"
		"Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L109\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L109-L112\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator(str name, str solver, dict:MX dae, dict opts)\n"
		"  integrator(str name, str solver, Function dae, dict opts)\n"
		"  integrator(str name, str solver, dict:SX dae, float t0, [float] tout, dict opts)\n"
		"  integrator(str name, str solver, dict:SX dae, float t0, float tf, dict opts)\n"
		"  integrator(str name, str solver, dict:MX dae, float t0, [float] tout, dict opts)\n"
		"  integrator(str name, str solver, dict:MX dae, float t0, float tf, dict opts)\n"
		"  integrator(str name, str solver, Function dae, float t0, [float] tout, dict opts)\n"
		"  integrator(str name, str solver, Function dae, float t0, float tf, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_integrator", (PyCFunction)_wrap_has_integrator, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_integrator(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L97\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L97-L99\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_integrator", (PyCFunction)_wrap_load_integrator, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_integrator(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L101\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L101-L103\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_integrator", (PyCFunction)_wrap_doc_integrator, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_integrator(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L105\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L105-L107\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"integrator_in", _wrap_integrator_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  integrator_in() -> [str]\n"
		"  integrator_in(int ind) -> str\n"
		"\n"
		"Get input scheme of integrators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L159\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L159-L163\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme of integrators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L159\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L159-L163\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get integrator input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L171\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L171-L183\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"integrator_out", _wrap_integrator_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  integrator_out() -> [str]\n"
		"  integrator_out(int ind) -> str\n"
		"\n"
		"Get integrator output scheme of integrators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L165\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L165-L169\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L185\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L185-L197\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  integrator_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get integrator output scheme of integrators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L165\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L165-L169\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"integrator_n_in", (PyCFunction)_wrap_integrator_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  integrator_n_in() -> int\n"
		"\n"
		"Get the number of integrator inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L199\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L199-L201\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"integrator_n_out", (PyCFunction)_wrap_integrator_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  integrator_n_out() -> int\n"
		"\n"
		"Get the number of integrator outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L203\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L203-L205\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dyn_in", _wrap_dyn_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dyn_in() -> [str]\n"
		"  dyn_in(int ind) -> str\n"
		"\n"
		"Get input scheme of simulators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L207-L209\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dyn_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme of simulators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L207-L209\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dyn_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get simulator input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L215\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L215-L217\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dyn_out", _wrap_dyn_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dyn_out() -> [str]\n"
		"  dyn_out(int ind) -> str\n"
		"\n"
		"Get simulator output scheme of simulators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L211\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L211-L213\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dyn_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25s\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L219\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L219-L221\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dyn_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get simulator output scheme of simulators.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L211\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L211-L213\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dyn_n_in", (PyCFunction)_wrap_dyn_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dyn_n_in() -> int\n"
		"\n"
		"Get the number of simulator inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L223\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L223-L225\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dyn_n_out", (PyCFunction)_wrap_dyn_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dyn_n_out() -> int\n"
		"\n"
		"Get the number of simulator outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.hpp#L227\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integrator.cpp#L227-L229\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic", _wrap_conic, METH_VARARGS, (char *)"\n"
		"  [INTERNAL]\n"
		"\n"
		"::\n"
		"\n"
		"  conic(str name, str solver, dict:Sparsity qp, dict opts) -> Function\n"
		"\n"
		"\n"
		"Create a QP solver Solves the following strictly convex problem:\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  min          1/2 x' H x + g' x\n"
		"  x\n"
		"\n"
		"  subject to\n"
		"  LBA <= A x <= UBA\n"
		"  LBX <= x   <= UBX\n"
		"\n"
		"  resize(Q x, np, np) + P >= 0 (psd)\n"
		"\n"
		"  with :\n"
		"  H sparse (n x n) positive definite\n"
		"  g dense  (n x 1)\n"
		"  A sparse (nc x n)\n"
		"  Q sparse symmetric (np^2 x n)\n"
		"  P sparse symmetric (np x nq)\n"
		"\n"
		"  n: number of decision variables (x)\n"
		"  nc: number of constraints (A)\n"
		"  nq: shape of psd constraint matrix\n"
		"\n"
		"\n"
		"\n"
		"If H is not positive-definite, the solver should throw an error.\n"
		"\n"
		"Second-order cone constraints can be added as psd constraints through \n"
		"a \n"
		"helper function 'soc':\n"
		"\n"
		"x in R^n y in R\n"
		"\n"
		"|| x ||_2 <= y\n"
		"\n"
		"<=>\n"
		"\n"
		"soc(x, y) psd\n"
		"\n"
		"This can be proven with soc(x, y)=[y*I x; x' y] using the Shur \n"
		"complement.\n"
		"\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Conic    |\n"
		"|                  |                 | of the variables |                  |\n"
		"|                  |                 | are discrete,    |                  |\n"
		"|                  |                 | i.e. integer-    |                  |\n"
		"|                  |                 | valued           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_problem    | OT_BOOL         | Print a numeric  | casadi::Conic    |\n"
		"|                  |                 | description of   |                  |\n"
		"|                  |                 | the problem      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		">Input scheme: casadi::ConicInput (CONIC_NUM_IN = 12)\n"
		"\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"|  Full name   | Short  |                   Description                    |\n"
		"+==============+========+==================================================+\n"
		"| CONIC_H      | h      | The square matrix H: sparse, (n x n). Only the   |\n"
		"|              |        | lower triangular part is actually used. The      |\n"
		"|              |        | matrix is assumed to be symmetrical.             |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_G      | g      | The vector g: dense, (n x 1)                     |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_A      | a      | The matrix A: sparse, (nc x n) - product with x  |\n"
		"|              |        | must be dense.                                   |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_LBA    | lba    | dense, (nc x 1)                                  |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_UBA    | uba    | dense, (nc x 1)                                  |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_LBX    | lbx    | dense, (n x 1)                                   |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_UBX    | ubx    | dense, (n x 1)                                   |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_X0     | x0     | dense, (n x 1)                                   |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_LAM_X0 | lam_x0 | dense                                            |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_LAM_A0 | lam_a0 | dense                                            |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_Q      | q      | The matrix Q: sparse symmetric, (np^2 x n)       |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"| CONIC_P      | p      | The matrix P: sparse symmetric, (np x np)        |\n"
		"+--------------+--------+--------------------------------------------------+\n"
		"\n"
		">Output scheme: casadi::ConicOutput (CONIC_NUM_OUT = 4)\n"
		"\n"
		"+-------------+-------+---------------------------------------------------+\n"
		"|  Full name  | Short |                    Description                    |\n"
		"+=============+=======+===================================================+\n"
		"| CONIC_X     | x     | The primal solution.                              |\n"
		"+-------------+-------+---------------------------------------------------+\n"
		"| CONIC_COST  | cost  | The optimal cost.                                 |\n"
		"+-------------+-------+---------------------------------------------------+\n"
		"| CONIC_LAM_A | lam_a | The dual solution corresponding to linear bounds. |\n"
		"+-------------+-------+---------------------------------------------------+\n"
		"| CONIC_LAM_X | lam_x | The dual solution corresponding to simple bounds. |\n"
		"+-------------+-------+---------------------------------------------------+\n"
		"\n"
		"List of plugins\n"
		"- cbc\n"
		"\n"
		"- clp\n"
		"\n"
		"- cplex\n"
		"\n"
		"- fatrop\n"
		"\n"
		"- gurobi\n"
		"\n"
		"- highs\n"
		"\n"
		"- hpipm\n"
		"\n"
		"- hpmpc\n"
		"\n"
		"- ooqp\n"
		"\n"
		"- osqp\n"
		"\n"
		"- proxqp\n"
		"\n"
		"- qpoases\n"
		"\n"
		"- sqic\n"
		"\n"
		"- superscs\n"
		"\n"
		"- ipqp\n"
		"\n"
		"- nlpsol\n"
		"\n"
		"- qrqp\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Conic.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"cbc\n"
		"---\n"
		"\n"
		"\n"
		"\n"
		"Interface to Cbc solver for sparse Quadratic Programs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_221\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"|     Id      |         Type          |            Description             |\n"
		"+=============+=======================+====================================+\n"
		"| cbc         | OT_DICT               | Options to be passed to CBC.Three  |\n"
		"|             |                       | sets of options are supported. The |\n"
		"|             |                       | first can be found in              |\n"
		"|             |                       | OsiSolverParameters.hpp. The       |\n"
		"|             |                       | second can be found in             |\n"
		"|             |                       | CbcModel.hpp. The third are        |\n"
		"|             |                       | options that can be passed to      |\n"
		"|             |                       | CbcMain1.                          |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| hot_start   | OT_BOOL               | Hot start with x0 [Default false]. |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_groups  | OT_INTVECTORVECTOR    | Definition of SOS groups by        |\n"
		"|             |                       | indices.                           |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_types   | OT_INTVECTOR          | Specify 1 or 2 for each SOS group. |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_weights | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS       |\n"
		"|             |                       | entries.                           |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"clp\n"
		"---\n"
		"\n"
		"\n"
		"\n"
		"Interface to Clp solver for sparse Quadratic Programs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22d\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----+---------+----------------------------------------------------------+\n"
		"| Id  |  Type   |                       Description                        |\n"
		"+=====+=========+==========================================================+\n"
		"| clp | OT_DICT | Options to be passed to CLP. A first set of options can  |\n"
		"|     |         | be found in ClpParameters.hpp. eg. 'PrimalTolerance'.    |\n"
		"|     |         | There are other options in additions. 'AutomaticScaling' |\n"
		"|     |         | (bool) is recognised. 'initial_solve' (default off)      |\n"
		"|     |         | activates the use of Clp's initialSolve.                 |\n"
		"|     |         | 'initial_solve_options' takes a dictionary with          |\n"
		"|     |         | following keys (see ClpSolve.hpp): SolveType (string),   |\n"
		"|     |         | PresolveType (string), NumberPasses, SpecialOptions      |\n"
		"|     |         | (intvectorvector), IndependentOptions (intvectorvector). |\n"
		"+-----+---------+----------------------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"cplex\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"Interface to Cplex solver for sparse Quadratic Programs\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22a\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"|       Id       |         Type          |           Description           |\n"
		"+================+=======================+=================================+\n"
		"| cplex          | OT_DICT               | Options to be passed to CPLEX   |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| dep_check      | OT_INT                | Detect redundant constraints.   |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| dump_filename  | OT_STRING             | The filename to dump to.        |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| dump_to_file   | OT_BOOL               | Dumps QP to file in CPLEX       |\n"
		"|                |                       | format.                         |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| mip_start      | OT_BOOL               | Hot start integers with x0      |\n"
		"|                |                       | [Default false].                |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| qp_method      | OT_INT                | Determines which CPLEX          |\n"
		"|                |                       | algorithm to use.               |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| sos_groups     | OT_INTVECTORVECTOR    | Definition of SOS groups by     |\n"
		"|                |                       | indices.                        |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| sos_types      | OT_INTVECTOR          | Specify 1 or 2 for each SOS     |\n"
		"|                |                       | group.                          |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| sos_weights    | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS    |\n"
		"|                |                       | entries.                        |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| tol            | OT_DOUBLE             | Tolerance of solver             |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| version_suffix | OT_STRING             | Specify version of cplex to     |\n"
		"|                |                       | load. We will attempt to load l |\n"
		"|                |                       | ibcplex<version_suffix>.[so|dll |\n"
		"|                |                       | |dylib]. Default value is taken |\n"
		"|                |                       | from CPLEX_VERSION env          |\n"
		"|                |                       | variable.                       |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"| warm_start     | OT_BOOL               | Use warm start with simplex     |\n"
		"|                |                       | methods (affects only the       |\n"
		"|                |                       | simplex methods).               |\n"
		"+----------------+-----------------------+---------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"fatrop\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Interface to Fatrop Solver\n"
		"\n"
		"In order to use this interface, you must:\n"
		"\n"
		"Decision variables must only by state and control, and the variable \n"
		"\n"
		"ordering must be [x0 u0 x1 u1 ...]\n"
		"\n"
		"The constraints must be in order: [ gap0 lincon0 gap1 lincon1 ]\n"
		"\n"
		"gap: Ak+1 = Ak xk + Bk uk lincon: yk= Ck xk + Dk uk\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"         A0 B0 -I\n"
		"         C0 D0\n"
		"                A1 B1 -I\n"
		"                C1 D1\n"
		"\n"
		"\n"
		"\n"
		"where I must be a diagonal sparse matrix\n"
		"Either supply all of N, nx, ng, nu \n"
		"options or rely on automatic \n"
		"detection\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_27g\n"
		"\n"
		">List of available options\n"
		"\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"|   Id   |     Type     |                  Description                  |\n"
		"+========+==============+===============================================+\n"
		"| N      | OT_INT       | OCP horizon                                   |\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"| fatrop | OT_DICT      | Options to be passed to fatrop                |\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"| ng     | OT_INTVECTOR | Number of non-dynamic constraints, length N+1 |\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"| nu     | OT_INTVECTOR | Number of controls, length N                  |\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"| nx     | OT_INTVECTOR | Number of states, length N+1                  |\n"
		"+--------+--------------+-----------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"gurobi\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Interface to the GUROBI Solver for quadratic programming\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22q\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"|     Id      |         Type          |            Description             |\n"
		"+=============+=======================+====================================+\n"
		"| gurobi      | OT_DICT               | Options to be passed to gurobi.    |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_groups  | OT_INTVECTORVECTOR    | Definition of SOS groups by        |\n"
		"|             |                       | indices.                           |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_types   | OT_INTVECTOR          | Specify 1 or 2 for each SOS group. |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| sos_weights | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS       |\n"
		"|             |                       | entries.                           |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"| vtype       | OT_STRINGVECTOR       | Type of variables: [CONTINUOUS|bin |\n"
		"|             |                       | ary|integer|semicont|semiint]      |\n"
		"+-------------+-----------------------+------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"highs\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"Interface to HiGHS solver for sparse Quadratic Programs, see \n"
		"highs.dev for \n"
		"more information and https://www.maths.ed.ac.uk/hall/HiGHS/HighsOptions.html\n"
		"  for a list of options.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22f\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------+---------+--------------------------------+\n"
		"|  Id   |  Type   |          Description           |\n"
		"+=======+=========+================================+\n"
		"| highs | OT_DICT | Options to be passed to HiGHS. |\n"
		"+-------+---------+--------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"hpipm\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"Interface to HPIPM Solver\n"
		"\n"
		"In order to use this interface, you must:\n"
		"\n"
		"Decision variables must only by state and control, and the variable \n"
		"\n"
		"ordering must be [x0 u0 x1 u1 ...]\n"
		"\n"
		"The constraints must be in order: [ gap0 lincon0 gap1 lincon1 ]\n"
		"\n"
		"gap: Ak+1 = Ak xk + Bk uk lincon: yk= Ck xk + Dk uk\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"         A0 B0 -I\n"
		"         C0 D0\n"
		"                A1 B1 -I\n"
		"                C1 D1\n"
		"\n"
		"\n"
		"\n"
		"where I must be a diagonal sparse matrix\n"
		"Either supply all of N, nx, ng, nu \n"
		"options or rely on automatic \n"
		"detection\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_242\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"|  Id   |     Type     |                   Description                    |\n"
		"+=======+==============+==================================================+\n"
		"| N     | OT_INT       | OCP horizon                                      |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"| hpipm | OT_DICT      | Options to be passed to hpipm                    |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"| inf   | OT_DOUBLE    | Replace infinities by this amount [default: 1e8] |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"| ng    | OT_INTVECTOR | Number of non-dynamic constraints, length N+1    |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"| nu    | OT_INTVECTOR | Number of controls, length N                     |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"| nx    | OT_INTVECTOR | Number of states, length N+1                     |\n"
		"+-------+--------------+--------------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"hpmpc\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"Interface to HMPC Solver\n"
		"\n"
		"In order to use this interface, you must:\n"
		"\n"
		"Decision variables must only by state and control, and the variable \n"
		"\n"
		"ordering must be [x0 u0 x1 u1 ...]\n"
		"\n"
		"The constraints must be in order: [ gap0 lincon0 gap1 lincon1 ]\n"
		"\n"
		"gap: Ak+1 = Ak xk + Bk uk lincon: yk= Ck xk + Dk uk\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"         A0 B0 -I\n"
		"         C0 D0\n"
		"                A1 B1 -I\n"
		"                C1 D1\n"
		"\n"
		"\n"
		"\n"
		"where I must be a diagonal sparse matrix\n"
		"Either supply all of N, nx, ng, nu \n"
		"options or rely on automatic \n"
		"detection\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22p\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------------+--------------+------------------------------------------+\n"
		"|       Id       |     Type     |               Description                |\n"
		"+================+==============+==========================================+\n"
		"| N              | OT_INT       | OCP horizon                              |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| blasfeo_target | OT_STRING    | hpmpc target                             |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| inf            | OT_DOUBLE    | HPMPC cannot handle infinities.          |\n"
		"|                |              | Infinities will be replaced by this      |\n"
		"|                |              | option's value.                          |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| max_iter       | OT_INT       | Max number of iterations                 |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| mu0            | OT_DOUBLE    | Max element in cost function as estimate |\n"
		"|                |              | of max multiplier                        |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| ng             | OT_INTVECTOR | Number of non-dynamic constraints,       |\n"
		"|                |              | length N+1                               |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| nu             | OT_INTVECTOR | Number of controls, length N             |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| nx             | OT_INTVECTOR | Number of states, length N+1             |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| print_level    | OT_INT       | Amount of diagnostic printing [Default:  |\n"
		"|                |              | 1].                                      |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| target         | OT_STRING    | hpmpc target                             |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| tol            | OT_DOUBLE    | Tolerance in the duality measure         |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"| warm_start     | OT_BOOL      | Use warm-starting                        |\n"
		"+----------------+--------------+------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"ooqp\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Interface to the OOQP Solver for quadratic programming The current \n"
		"\n"
		"implementation assumes that OOQP is configured with the MA27 sparse \n"
		"linear \n"
		"solver.\n"
		"\n"
		"NOTE: when doing multiple calls to evaluate(), check if you need to \n"
		"\n"
		"reInit();\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_222\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------+-----------+------------------------------------------------+\n"
		"|     Id      |   Type    |                  Description                   |\n"
		"+=============+===========+================================================+\n"
		"| artol       | OT_DOUBLE | tolerance as provided with setArTol to OOQP    |\n"
		"+-------------+-----------+------------------------------------------------+\n"
		"| mutol       | OT_DOUBLE | tolerance as provided with setMuTol to OOQP    |\n"
		"+-------------+-----------+------------------------------------------------+\n"
		"| print_level | OT_INT    | Print level. OOQP listens to print_level 0, 10 |\n"
		"|             |           | and 100                                        |\n"
		"+-------------+-----------+------------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"osqp\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Interface to the OSQP Solver for quadratic programming\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_220\n"
		"\n"
		"Interface to the PROXQP Solver for quadratic programming\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_243\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"|        Id         |  Type   |                Description                 |\n"
		"+===================+=========+============================================+\n"
		"| osqp              | OT_DICT | const Options to be passed to osqp.        |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"| warm_start_dual   | OT_BOOL | Use lam_a0 and lam_x0 input to warmstart   |\n"
		"|                   |         | [Default: truw].                           |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"| warm_start_primal | OT_BOOL | Use x0 input to warmstart [Default: true]. |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"proxqp\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"|        Id         |  Type   |                Description                 |\n"
		"+===================+=========+============================================+\n"
		"| proxqp            | OT_DICT | const proxqp options.                      |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"| warm_start_dual   | OT_BOOL | Use y and z input to warmstart [Default:   |\n"
		"|                   |         | true].                                     |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"| warm_start_primal | OT_BOOL | Use x input to warmstart [Default: true].  |\n"
		"+-------------------+---------+--------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"qpoases\n"
		"-------\n"
		"\n"
		"\n"
		"\n"
		"Interface to QPOases Solver for quadratic programming\n"
		"\n"
		"::\n"
		"\n"
		"  Extra doc: https://github.com/casadi/casadi/wiki/L_22o \n"
		"\n"
		"\n"
		"\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"|              Id               |   Type    |         Description          |\n"
		"+===============================+===========+==============================+\n"
		"| CPUtime                       | OT_DOUBLE | The maximum allowed CPU time |\n"
		"|                               |           | in seconds for the whole     |\n"
		"|                               |           | initialisation (and the      |\n"
		"|                               |           | actually required one on     |\n"
		"|                               |           | output). Disabled if unset.  |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| boundRelaxation               | OT_DOUBLE | Initial relaxation of bounds |\n"
		"|                               |           | to start homotopy and        |\n"
		"|                               |           | initial value for far        |\n"
		"|                               |           | bounds.                      |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| boundTolerance                | OT_DOUBLE | If upper and lower bounds    |\n"
		"|                               |           | differ less than this        |\n"
		"|                               |           | tolerance, they are regarded |\n"
		"|                               |           | equal, i.e. as equality      |\n"
		"|                               |           | constraint.                  |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableCholeskyRefactorisation | OT_INT    | Specifies the frequency of a |\n"
		"|                               |           | full re-factorisation of     |\n"
		"|                               |           | projected Hessian matrix: 0: |\n"
		"|                               |           | turns them off, 1: uses them |\n"
		"|                               |           | at each iteration etc.       |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableDriftCorrection         | OT_INT    | Specifies the frequency of   |\n"
		"|                               |           | drift corrections: 0: turns  |\n"
		"|                               |           | them off.                    |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableEqualities              | OT_BOOL   | Specifies whether equalities |\n"
		"|                               |           | should be treated as always  |\n"
		"|                               |           | active (True) or not (False) |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableFarBounds               | OT_BOOL   | Enables the use of far       |\n"
		"|                               |           | bounds.                      |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableFlippingBounds          | OT_BOOL   | Enables the use of flipping  |\n"
		"|                               |           | bounds.                      |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableFullLITests             | OT_BOOL   | Enables condition-hardened   |\n"
		"|                               |           | (but more expensive) LI      |\n"
		"|                               |           | test.                        |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableInertiaCorrection       | OT_BOOL   | Should working set be        |\n"
		"|                               |           | repaired when negative       |\n"
		"|                               |           | curvature is discovered      |\n"
		"|                               |           | during hotstart.             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableNZCTests                | OT_BOOL   | Enables nonzero curvature    |\n"
		"|                               |           | tests.                       |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableRamping                 | OT_BOOL   | Enables ramping.             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| enableRegularisation          | OT_BOOL   | Enables automatic Hessian    |\n"
		"|                               |           | regularisation.              |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsDen                        | OT_DOUBLE | Denominator tolerance for    |\n"
		"|                               |           | ratio tests.                 |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsFlipping                   | OT_DOUBLE | Tolerance of squared         |\n"
		"|                               |           | Cholesky diagonal factor     |\n"
		"|                               |           | which triggers flipping      |\n"
		"|                               |           | bound.                       |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsIterRef                    | OT_DOUBLE | Early termination tolerance  |\n"
		"|                               |           | for iterative refinement.    |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsLITests                    | OT_DOUBLE | Tolerance for linear         |\n"
		"|                               |           | independence tests.          |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsNZCTests                   | OT_DOUBLE | Tolerance for nonzero        |\n"
		"|                               |           | curvature tests.             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsNum                        | OT_DOUBLE | Numerator tolerance for      |\n"
		"|                               |           | ratio tests.                 |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| epsRegularisation             | OT_DOUBLE | Scaling factor of identity   |\n"
		"|                               |           | matrix used for Hessian      |\n"
		"|                               |           | regularisation.              |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| finalRamping                  | OT_DOUBLE | Final value for ramping      |\n"
		"|                               |           | strategy.                    |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| growFarBounds                 | OT_DOUBLE | Factor to grow far bounds.   |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| hessian_type                  | OT_STRING | Type of Hessian - see        |\n"
		"|                               |           | qpOASES documentation [UNKNO |\n"
		"|                               |           | WN|posdef|semidef|indef|zero |\n"
		"|                               |           | |identity]]                  |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| initialFarBounds              | OT_DOUBLE | Initial size for far bounds. |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| initialRamping                | OT_DOUBLE | Start value for ramping      |\n"
		"|                               |           | strategy.                    |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| initialStatusBounds           | OT_STRING | Initial status of bounds at  |\n"
		"|                               |           | first iteration.             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| linsol_plugin                 | OT_STRING | Linear solver plugin         |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| maxDualJump                   | OT_DOUBLE | Maximum allowed jump in dual |\n"
		"|                               |           | variables in linear          |\n"
		"|                               |           | independence tests.          |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| maxPrimalJump                 | OT_DOUBLE | Maximum allowed jump in      |\n"
		"|                               |           | primal variables in nonzero  |\n"
		"|                               |           | curvature tests.             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| max_schur                     | OT_INT    | Maximal number of Schur      |\n"
		"|                               |           | updates [75]                 |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| nWSR                          | OT_INT    | The maximum number of        |\n"
		"|                               |           | working set recalculations   |\n"
		"|                               |           | to be performed during the   |\n"
		"|                               |           | initial homotopy. Default is |\n"
		"|                               |           | 5(nx + nc)                   |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| numRefinementSteps            | OT_INT    | Maximum number of iterative  |\n"
		"|                               |           | refinement steps.            |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| numRegularisationSteps        | OT_INT    | Maximum number of successive |\n"
		"|                               |           | regularisation steps.        |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| printLevel                    | OT_STRING | Defines the amount of text   |\n"
		"|                               |           | output during QP solution,   |\n"
		"|                               |           | see Section 5.7              |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| schur                         | OT_BOOL   | Use Schur Complement         |\n"
		"|                               |           | Approach [false]             |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| sparse                        | OT_BOOL   | Formulate the QP using       |\n"
		"|                               |           | sparse matrices. [false]     |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"| terminationTolerance          | OT_DOUBLE | Relative termination         |\n"
		"|                               |           | tolerance to stop homotopy.  |\n"
		"+-------------------------------+-----------+------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"sqic\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Interface to the SQIC solver for quadratic programming\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21s\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"superscs\n"
		"--------\n"
		"\n"
		"\n"
		"\n"
		"Interface to the SuperSCS solver for conic programming\n"
		"\n"
		"Joris Gillis, 2019\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21z\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------+---------+-----------------------------------+\n"
		"|    Id    |  Type   |            Description            |\n"
		"+==========+=========+===================================+\n"
		"| superscs | OT_DICT | Options to be passed to superscs. |\n"
		"+----------+---------+-----------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"ipqp\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Solves QPs using a Mehrotra predictor-corrector interior point method\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23c\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"|          Id           |   Type    |             Description              |\n"
		"+=======================+===========+======================================+\n"
		"| constr_viol_tol       | OT_DOUBLE | Constraint violation tolerance       |\n"
		"|                       |           | [1e-8].                              |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| dual_inf_tol          | OT_DOUBLE | Dual feasibility violation tolerance |\n"
		"|                       |           | [1e-8]                               |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| linear_solver         | OT_STRING | A custom linear solver creator       |\n"
		"|                       |           | function [default: ldl]              |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| linear_solver_options | OT_DICT   | Options to be passed to the linear   |\n"
		"|                       |           | solver                               |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| max_iter              | OT_INT    | Maximum number of iterations [1000]. |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| min_lam               | OT_DOUBLE | Smallest multiplier treated as       |\n"
		"|                       |           | inactive for the initial active set  |\n"
		"|                       |           | [0].                                 |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| print_header          | OT_BOOL   | Print header [true].                 |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| print_info            | OT_BOOL   | Print info [true].                   |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| print_iter            | OT_BOOL   | Print iterations [true].             |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"nlpsol\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Solve QPs using an  Nlpsol Use the 'nlpsol' option to specify the NLP solver\n"
		" to use.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_235\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------------+-----------+---------------------------------+\n"
		"|       Id       |   Type    |           Description           |\n"
		"+================+===========+=================================+\n"
		"| nlpsol         | OT_STRING | Name of solver.                 |\n"
		"+----------------+-----------+---------------------------------+\n"
		"| nlpsol_options | OT_DICT   | Options to be passed to solver. |\n"
		"+----------------+-----------+---------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"qrqp\n"
		"----\n"
		"\n"
		"\n"
		"\n"
		"Solve QPs using an active-set method\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22y\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"|       Id        |   Type    |                Description                 |\n"
		"+=================+===========+============================================+\n"
		"| constr_viol_tol | OT_DOUBLE | Constraint violation tolerance [1e-8].     |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| dual_inf_tol    | OT_DOUBLE | Dual feasibility violation tolerance       |\n"
		"|                 |           | [1e-8]                                     |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| max_iter        | OT_INT    | Maximum number of iterations [1000].       |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| min_lam         | OT_DOUBLE | Smallest multiplier treated as inactive    |\n"
		"|                 |           | for the initial active set [0].            |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| print_header    | OT_BOOL   | Print header [true].                       |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| print_info      | OT_BOOL   | Print info [true].                         |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| print_iter      | OT_BOOL   | Print iterations [true].                   |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| print_lincomb   | OT_BOOL   | Print dependant linear combinations of     |\n"
		"|                 |           | constraints [false]. Printed numbers are   |\n"
		"|                 |           | 0-based indices into the vector of [simple |\n"
		"|                 |           | bounds;linear bounds]                      |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"\n"
		"Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21n\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L43\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L43-L46\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"qpsol", _wrap_qpsol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  qpsol(str name, str solver, dict:SX qp, dict opts) -> Function\n"
		"  qpsol(str name, str solver, dict:MX qp, dict opts) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_in", _wrap_conic_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_in() -> [str]\n"
		"  conic_in(int ind) -> str\n"
		"\n"
		"Get input scheme of QP solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ee\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L60\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L60-L64\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme of QP solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ee\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L60\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L60-L64\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get QP solver input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1eg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L72\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L72-L89\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_out", _wrap_conic_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_out() -> [str]\n"
		"  conic_out(int ind) -> str\n"
		"\n"
		"Get QP solver output scheme of QP solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ef\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L66\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L66-L70\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1eh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L91\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L91-L100\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get QP solver output scheme of QP solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ef\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L66\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L66-L70\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_n_in", (PyCFunction)_wrap_conic_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_n_in() -> int\n"
		"\n"
		"Get the number of QP solver inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ei\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L102\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L102-L104\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_n_out", (PyCFunction)_wrap_conic_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_n_out() -> int\n"
		"\n"
		"Get the number of QP solver outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ej\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L106\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L106-L108\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_options", (PyCFunction)_wrap_conic_options, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_options(str name) -> [str]\n"
		"\n"
		"Get all options for a plugin.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ek\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L542\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L542-L544\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_option_type", _wrap_conic_option_type, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_option_type(str name, str op) -> str\n"
		"\n"
		"Get type info for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1el\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L546\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L546-L548\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_option_info", _wrap_conic_option_info, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_option_info(str name, str op) -> str\n"
		"\n"
		"Get documentation for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1em\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L550\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L550-L552\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_conic", (PyCFunction)_wrap_has_conic, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_conic(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L31\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L31-L33\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_conic", (PyCFunction)_wrap_load_conic, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_conic(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L35\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L35-L37\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_conic", (PyCFunction)_wrap_doc_conic, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_conic(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L39\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L39-L41\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conic_debug", _wrap_conic_debug, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  conic_debug(Function f, std::ostream & file)\n"
		"  conic_debug(Function f, str filename)\n"
		"\n"
		"Generate native code in the interfaced language for debugging\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L48\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L48-L52\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_debug(Function f, std::ostream & file)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Generate native code in the interfaced language for debugging\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L54\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L54-L58\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  conic_debug(Function f, str filename)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Generate native code in the interfaced language for debugging\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.hpp#L48\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/conic.cpp#L48-L52\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol", _wrap_nlpsol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol(str name, str solver, Importer compiler, dict opts) -> Function\n"
		"  nlpsol(str name, str solver, NlpBuilder nl, dict opts) -> Function\n"
		"  nlpsol(str name, str solver, dict:SX nlp, dict opts) -> Function\n"
		"  nlpsol(str name, str solver, dict:MX nlp, dict opts) -> Function\n"
		"  nlpsol(str name, str solver, str fname, dict opts) -> Function\n"
		"  nlpsol(str name, str solver, Function nlp, dict opts) -> Function\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol(str name, str solver, dict:SX nlp, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL]\n"
		"\n"
		"Create an NLP solver Creates a solver for the following parametric \n"
		"\n"
		"nonlinear program (NLP):\n"
		"\n"
		"::\n"
		"\n"
		"  min          F(x, p)\n"
		"  x\n"
		"\n"
		"  subject to\n"
		"  LBX <=   x    <= UBX\n"
		"  LBG <= G(x, p) <= UBG\n"
		"  p  == P\n"
		"\n"
		"  nx: number of decision variables\n"
		"  ng: number of constraints\n"
		"  np: number of parameters\n"
		"\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| bound_consistenc | OT_BOOL         | Ensure that      | casadi::Nlpsol   |\n"
		"| y                |                 | primal-dual      |                  |\n"
		"|                  |                 | solution is      |                  |\n"
		"|                  |                 | consistent with  |                  |\n"
		"|                  |                 | the bounds       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| calc_f           | OT_BOOL         | Calculate 'f' in | casadi::Nlpsol   |\n"
		"|                  |                 | the Nlpsol base  |                  |\n"
		"|                  |                 | class            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| calc_g           | OT_BOOL         | Calculate 'g' in | casadi::Nlpsol   |\n"
		"|                  |                 | the Nlpsol base  |                  |\n"
		"|                  |                 | class            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| calc_lam_p       | OT_BOOL         | Calculate        | casadi::Nlpsol   |\n"
		"|                  |                 | 'lam_p' in the   |                  |\n"
		"|                  |                 | Nlpsol base      |                  |\n"
		"|                  |                 | class            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| calc_lam_x       | OT_BOOL         | Calculate        | casadi::Nlpsol   |\n"
		"|                  |                 | 'lam_x' in the   |                  |\n"
		"|                  |                 | Nlpsol base      |                  |\n"
		"|                  |                 | class            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| calc_multipliers | OT_BOOL         | Calculate        | casadi::Nlpsol   |\n"
		"|                  |                 | Lagrange         |                  |\n"
		"|                  |                 | multipliers in   |                  |\n"
		"|                  |                 | the Nlpsol base  |                  |\n"
		"|                  |                 | class            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| common_options   | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | auto-generated   | nction           |\n"
		"|                  |                 | functions        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| detect_simple_bo | OT_BOOL         | Automatically    | casadi::Nlpsol   |\n"
		"| unds             |                 | detect simple    |                  |\n"
		"|                  |                 | bounds (lbx/ubx) |                  |\n"
		"|                  |                 | (default false). |                  |\n"
		"|                  |                 | This is          |                  |\n"
		"|                  |                 | hopefully        |                  |\n"
		"|                  |                 | beneficial to    |                  |\n"
		"|                  |                 | speed and        |                  |\n"
		"|                  |                 | robustness but   |                  |\n"
		"|                  |                 | may also have    |                  |\n"
		"|                  |                 | adverse affects: |                  |\n"
		"|                  |                 | 1) Subtleties in |                  |\n"
		"|                  |                 | heuristics and   |                  |\n"
		"|                  |                 | stopping         |                  |\n"
		"|                  |                 | criteria may     |                  |\n"
		"|                  |                 | change the       |                  |\n"
		"|                  |                 | solution, 2)     |                  |\n"
		"|                  |                 | IPOPT may lie    |                  |\n"
		"|                  |                 | about            |                  |\n"
		"|                  |                 | multipliers of   |                  |\n"
		"|                  |                 | simple equality  |                  |\n"
		"|                  |                 | bounds unless 'f |                  |\n"
		"|                  |                 | ixed_variable_tr |                  |\n"
		"|                  |                 | eatment' is set  |                  |\n"
		"|                  |                 | to               |                  |\n"
		"|                  |                 | 'relax_bounds'.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| detect_simple_bo | OT_BOOLVECTOR   | For internal use | casadi::Nlpsol   |\n"
		"| unds_is_simple   |                 | only.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| detect_simple_bo | OT_FUNCTION     | For internal use | casadi::Nlpsol   |\n"
		"| unds_parts       |                 | only.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| detect_simple_bo | OT_INTVECTOR    | For internal use | casadi::Nlpsol   |\n"
		"| unds_target_x    |                 | only.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Nlpsol   |\n"
		"|                  |                 | of the variables |                  |\n"
		"|                  |                 | are discrete,    |                  |\n"
		"|                  |                 | i.e. integer-    |                  |\n"
		"|                  |                 | valued           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| eval_errors_fata | OT_BOOL         | When errors      | casadi::Nlpsol   |\n"
		"| l                |                 | occur during     |                  |\n"
		"|                  |                 | evaluation of    |                  |\n"
		"|                  |                 | f,g,...,stop the |                  |\n"
		"|                  |                 | iterations       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |\n"
		"|                  |                 | SX expressions   | nction           |\n"
		"|                  |                 | in problem       |                  |\n"
		"|                  |                 | formulation      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ignore_check_vec | OT_BOOL         | If set to true,  | casadi::Nlpsol   |\n"
		"|                  |                 | the input shape  |                  |\n"
		"|                  |                 | of F will not be |                  |\n"
		"|                  |                 | checked.         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| iteration_callba | OT_FUNCTION     | A function that  | casadi::Nlpsol   |\n"
		"| ck               |                 | will be called   |                  |\n"
		"|                  |                 | at each          |                  |\n"
		"|                  |                 | iteration with   |                  |\n"
		"|                  |                 | the solver as    |                  |\n"
		"|                  |                 | input. Check     |                  |\n"
		"|                  |                 | documentation of |                  |\n"
		"|                  |                 | Callback .       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| iteration_callba | OT_BOOL         | If set to true,  | casadi::Nlpsol   |\n"
		"| ck_ignore_errors |                 | errors thrown by |                  |\n"
		"|                  |                 | iteration_callba |                  |\n"
		"|                  |                 | ck will be       |                  |\n"
		"|                  |                 | ignored.         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| iteration_callba | OT_INT          | Only call the    | casadi::Nlpsol   |\n"
		"| ck_step          |                 | callback         |                  |\n"
		"|                  |                 | function every   |                  |\n"
		"|                  |                 | few iterations.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| min_lam          | OT_DOUBLE       | Minimum allowed  | casadi::Nlpsol   |\n"
		"|                  |                 | multiplier value |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |\n"
		"|                  |                 | problem          | nction           |\n"
		"|                  |                 | functions to be  |                  |\n"
		"|                  |                 | monitored        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| no_nlp_grad      | OT_BOOL         | Prevent the      | casadi::Nlpsol   |\n"
		"|                  |                 | creation of the  |                  |\n"
		"|                  |                 | 'nlp_grad'       |                  |\n"
		"|                  |                 | function         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| oracle_options   | OT_DICT         | Options to be    | casadi::Nlpsol   |\n"
		"|                  |                 | passed to the    |                  |\n"
		"|                  |                 | oracle function  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| sens_linsol      | OT_STRING       | Linear solver    | casadi::Nlpsol   |\n"
		"|                  |                 | used for         |                  |\n"
		"|                  |                 | parametric       |                  |\n"
		"|                  |                 | sensitivities    |                  |\n"
		"|                  |                 | (default 'qr').  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| sens_linsol_opti | OT_DICT         | Linear solver    | casadi::Nlpsol   |\n"
		"| ons              |                 | options used for |                  |\n"
		"|                  |                 | parametric       |                  |\n"
		"|                  |                 | sensitivities.   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |\n"
		"| gs               |                 | generated from   | nction           |\n"
		"|                  |                 | function         |                  |\n"
		"|                  |                 | evaluations      |                  |\n"
		"|                  |                 | [true]           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| specific_options | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | specific auto-   | nction           |\n"
		"|                  |                 | generated        |                  |\n"
		"|                  |                 | functions,       |                  |\n"
		"|                  |                 | overwriting the  |                  |\n"
		"|                  |                 | defaults from    |                  |\n"
		"|                  |                 | common_options.  |                  |\n"
		"|                  |                 | Nested           |                  |\n"
		"|                  |                 | dictionary.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose_init     | OT_BOOL         | Print out timing | casadi::Nlpsol   |\n"
		"|                  |                 | information      |                  |\n"
		"|                  |                 | about the        |                  |\n"
		"|                  |                 | different stages |                  |\n"
		"|                  |                 | of               |                  |\n"
		"|                  |                 | initialization   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| warn_initial_bou | OT_BOOL         | Warn if the      | casadi::Nlpsol   |\n"
		"| nds              |                 | initial guess    |                  |\n"
		"|                  |                 | does not satisfy |                  |\n"
		"|                  |                 | LBX and UBX      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		">Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)\n"
		"\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"|   Full name   | Short  |                   Description                   |\n"
		"+===============+========+=================================================+\n"
		"| NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |\n"
		"|               |        | default -inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |\n"
		"|               |        | default +inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |\n"
		"|               |        | guess (nx x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |\n"
		"|               |        | guess (ng x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"\n"
		">Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)\n"
		"\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"|  Full name   | Short |                    Description                    |\n"
		"+==============+=======+===================================================+\n"
		"| NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |\n"
		"|              |       | x 1)                                              |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |\n"
		"|              |       | solution (nx x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |\n"
		"|              |       | solution (ng x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |\n"
		"|              |       | solution (np x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"\n"
		"List of plugins\n"
		"- AmplInterface\n"
		"\n"
		"- blocksqp\n"
		"\n"
		"- bonmin\n"
		"\n"
		"- ipopt\n"
		"\n"
		"- knitro\n"
		"\n"
		"- snopt\n"
		"\n"
		"- worhp\n"
		"\n"
		"- feasiblesqpmethod\n"
		"\n"
		"- qrsqp\n"
		"\n"
		"- scpgen\n"
		"\n"
		"- sqpmethod\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Nlpsol.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"AmplInterface\n"
		"-------------\n"
		"\n"
		"\n"
		"\n"
		">List of available options\n"
		"\n"
		"+--------+-----------+--------------------+\n"
		"|   Id   |   Type    |    Description     |\n"
		"+========+===========+====================+\n"
		"| solver | OT_STRING | AMPL solver binary |\n"
		"+--------+-----------+--------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"blocksqp\n"
		"--------\n"
		"\n"
		"\n"
		"\n"
		"This is a modified version of blockSQP by Janka et al.\n"
		"\n"
		"Dennis Janka, Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_224\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"|             Id             |   Type    |           Description           |\n"
		"+============================+===========+=================================+\n"
		"| block_hess                 | OT_INT    | Blockwise Hessian               |\n"
		"|                            |           | approximation?                  |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| col_eps                    | OT_DOUBLE | Epsilon for COL scaling         |\n"
		"|                            |           | strategy                        |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| col_tau1                   | OT_DOUBLE | tau1 for COL scaling strategy   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| col_tau2                   | OT_DOUBLE | tau2 for COL scaling strategy   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| conv_strategy              | OT_INT    | Convexification strategy        |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| delta                      | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| delta_h0                   | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| eps                        | OT_DOUBLE | Values smaller than this are    |\n"
		"|                            |           | regarded as numerically zero    |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| eta                        | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| fallback_scaling           | OT_INT    | If indefinite update is used,   |\n"
		"|                            |           | the type of fallback strategy   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| fallback_update            | OT_INT    | If indefinite update is used,   |\n"
		"|                            |           | the type of fallback strategy   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| gamma_f                    | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| gamma_theta                | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| globalization              | OT_BOOL   | Enable globalization            |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_damp                  | OT_INT    | Activate Powell damping for     |\n"
		"|                            |           | BFGS                            |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_damp_fac              | OT_DOUBLE | Damping factor for BFGS Powell  |\n"
		"|                            |           | modification                    |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_lim_mem               | OT_INT    | Full or limited memory          |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_memsize               | OT_INT    | Memory size for L-BFGS updates  |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_scaling               | OT_INT    | Scaling strategy for Hessian    |\n"
		"|                            |           | approximation                   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| hess_update                | OT_INT    | Type of Hessian approximation   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| ini_hess_diag              | OT_DOUBLE | Initial Hessian guess: diagonal |\n"
		"|                            |           | matrix diag(iniHessDiag)        |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| kappa_f                    | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| kappa_minus                | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| kappa_plus                 | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| kappa_plus_max             | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| kappa_soc                  | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| linsol                     | OT_STRING | The linear solver to be used by |\n"
		"|                            |           | the QP method                   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_consec_reduced_steps   | OT_INT    | Maximum number of consecutive   |\n"
		"|                            |           | reduced steps                   |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_consec_skipped_updates | OT_INT    | Maximum number of consecutive   |\n"
		"|                            |           | skipped updates                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_conv_qp                | OT_INT    | How many additional QPs may be  |\n"
		"|                            |           | solved for convexification per  |\n"
		"|                            |           | iteration?                      |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_it_qp                  | OT_INT    | Maximum number of QP iterations |\n"
		"|                            |           | per SQP iteration               |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_iter                   | OT_INT    | Maximum number of SQP           |\n"
		"|                            |           | iterations                      |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_line_search            | OT_INT    | Maximum number of steps in line |\n"
		"|                            |           | search                          |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_soc_iter               | OT_INT    | Maximum number of SOC line      |\n"
		"|                            |           | search iterations               |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| max_time_qp                | OT_DOUBLE | Maximum number of time in       |\n"
		"|                            |           | seconds per QP solve per SQP    |\n"
		"|                            |           | iteration                       |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| nlinfeastol                | OT_DOUBLE | Nonlinear feasibility tolerance |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| obj_lo                     | OT_DOUBLE | Lower bound on objective        |\n"
		"|                            |           | function [-inf]                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| obj_up                     | OT_DOUBLE | Upper bound on objective        |\n"
		"|                            |           | function [inf]                  |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| opttol                     | OT_DOUBLE | Optimality tolerance            |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| print_header               | OT_BOOL   | Print solver header at startup  |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| print_iteration            | OT_BOOL   | Print SQP iterations            |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| print_maxit_reached        | OT_BOOL   | Print error when maximum number |\n"
		"|                            |           | of SQP iterations reached       |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| qp_init                    | OT_BOOL   | Use warmstarting                |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| qpsol                      | OT_STRING | The QP solver to be used by the |\n"
		"|                            |           | SQP method                      |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| qpsol_options              | OT_DICT   | Options to be passed to the QP  |\n"
		"|                            |           | solver                          |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| restore_feas               | OT_BOOL   | Use feasibility restoration     |\n"
		"|                            |           | phase                           |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| rho                        | OT_DOUBLE | Feasibility restoration phase   |\n"
		"|                            |           | parameter                       |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| s_f                        | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| s_theta                    | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| schur                      | OT_BOOL   | Use qpOASES Schur compliment    |\n"
		"|                            |           | approach                        |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| skip_first_globalization   | OT_BOOL   | No globalization strategy in    |\n"
		"|                            |           | first iteration                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| theta_max                  | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| theta_min                  | OT_DOUBLE | Filter line search parameter,   |\n"
		"|                            |           | cf. IPOPT paper                 |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| warmstart                  | OT_BOOL   | Use warmstarting                |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| which_second_derv          | OT_INT    | For which block should second   |\n"
		"|                            |           | derivatives be provided by the  |\n"
		"|                            |           | user                            |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"| zeta                       | OT_DOUBLE | Feasibility restoration phase   |\n"
		"|                            |           | parameter                       |\n"
		"+----------------------------+-----------+---------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"bonmin\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"When in warmstart mode, output NLPSOL_LAM_X may be used as input\n"
		"\n"
		"NOTE: Even when max_iter == 0, it is not guaranteed that \n"
		"input(NLPSOL_X0) \n"
		"== output(NLPSOL_X). Indeed if bounds on X or \n"
		"constraints are unmet, they \n"
		"will differ.\n"
		"\n"
		"For a good tutorial on BONMIN, see \n"
		"http://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf\n"
		"\n"
		"A good resource about the algorithms in BONMIN is: Wachter and L. T. \n"
		"\n"
		"Biegler, On the Implementation of an Interior-Point Filter Line-Search\n"
		"\n"
		"Algorithm for Large-Scale Nonlinear Programming, Mathematical \n"
		"Programming \n"
		"106(1), pp. 25-57, 2006 (As Research Report RC 23149, IBM \n"
		"T. J. Watson \n"
		"Research Center, Yorktown, USA\n"
		"\n"
		"Caveats:\n"
		"with default options, multipliers for the decision variables are \n"
		"wrong\n"
		" for equality constraints. Change the 'fixed_variable_treatment' to \n"
		"\n"
		"'make_constraint' or 'relax_bounds' to obtain correct results.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_223\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"|           Id            |         Type          |      Description       |\n"
		"+=========================+=======================+========================+\n"
		"| bonmin                  | OT_DICT               | Options to be passed   |\n"
		"|                         |                       | to BONMIN              |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| con_integer_md          | OT_DICT               | Integer metadata (a    |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of integers) about     |\n"
		"|                         |                       | constraints to be      |\n"
		"|                         |                       | passed to BONMIN       |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| con_numeric_md          | OT_DICT               | Numeric metadata (a    |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of reals) about        |\n"
		"|                         |                       | constraints to be      |\n"
		"|                         |                       | passed to BONMIN       |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| con_string_md           | OT_DICT               | String metadata (a     |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of strings) about      |\n"
		"|                         |                       | constraints to be      |\n"
		"|                         |                       | passed to BONMIN       |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| grad_f                  | OT_FUNCTION           | Function for           |\n"
		"|                         |                       | calculating the        |\n"
		"|                         |                       | gradient of the        |\n"
		"|                         |                       | objective (column,     |\n"
		"|                         |                       | autogenerated by       |\n"
		"|                         |                       | default)               |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| grad_f_options          | OT_DICT               | Options for the        |\n"
		"|                         |                       | autogenerated gradient |\n"
		"|                         |                       | of the objective.      |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| hess_lag                | OT_FUNCTION           | Function for           |\n"
		"|                         |                       | calculating the        |\n"
		"|                         |                       | Hessian of the         |\n"
		"|                         |                       | Lagrangian             |\n"
		"|                         |                       | (autogenerated by      |\n"
		"|                         |                       | default)               |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| hess_lag_options        | OT_DICT               | Options for the        |\n"
		"|                         |                       | autogenerated Hessian  |\n"
		"|                         |                       | of the Lagrangian.     |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| jac_g                   | OT_FUNCTION           | Function for           |\n"
		"|                         |                       | calculating the        |\n"
		"|                         |                       | Jacobian of the        |\n"
		"|                         |                       | constraints            |\n"
		"|                         |                       | (autogenerated by      |\n"
		"|                         |                       | default)               |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| jac_g_options           | OT_DICT               | Options for the        |\n"
		"|                         |                       | autogenerated Jacobian |\n"
		"|                         |                       | of the constraints.    |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| pass_nonlinear_constrai | OT_BOOL               | Pass list of           |\n"
		"| nts                     |                       | constraints entering   |\n"
		"|                         |                       | nonlinearly to BONMIN  |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| pass_nonlinear_variable | OT_BOOL               | Pass list of variables |\n"
		"| s                       |                       | entering nonlinearly   |\n"
		"|                         |                       | to BONMIN              |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| sos1_groups             | OT_INTVECTORVECTOR    | Options for the        |\n"
		"|                         |                       | autogenerated gradient |\n"
		"|                         |                       | of the objective.      |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| sos1_priorities         | OT_INTVECTOR          | Options for the        |\n"
		"|                         |                       | autogenerated gradient |\n"
		"|                         |                       | of the objective.      |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| sos1_weights            | OT_DOUBLEVECTORVECTOR | Options for the        |\n"
		"|                         |                       | autogenerated gradient |\n"
		"|                         |                       | of the objective.      |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| var_integer_md          | OT_DICT               | Integer metadata (a    |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of integers) about     |\n"
		"|                         |                       | variables to be passed |\n"
		"|                         |                       | to BONMIN              |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| var_numeric_md          | OT_DICT               | Numeric metadata (a    |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of reals) about        |\n"
		"|                         |                       | variables to be passed |\n"
		"|                         |                       | to BONMIN              |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"| var_string_md           | OT_DICT               | String metadata (a     |\n"
		"|                         |                       | dictionary with lists  |\n"
		"|                         |                       | of strings) about      |\n"
		"|                         |                       | variables to be passed |\n"
		"|                         |                       | to BONMIN              |\n"
		"+-------------------------+-----------------------+------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"ipopt\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"When in warmstart mode, output NLPSOL_LAM_X may be used as input\n"
		"\n"
		"NOTE: Even when max_iter == 0, it is not guaranteed that \n"
		"input(NLPSOL_X0) \n"
		"== output(NLPSOL_X). Indeed if bounds on X or \n"
		"constraints are unmet, they \n"
		"will differ.\n"
		"\n"
		"For a good tutorial on IPOPT, see \n"
		"http://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf\n"
		"\n"
		"A good resource about the algorithms in IPOPT is: Wachter and L. T. \n"
		"\n"
		"Biegler, On the Implementation of an Interior-Point Filter Line-Search\n"
		"\n"
		"Algorithm for Large-Scale Nonlinear Programming, Mathematical \n"
		"Programming \n"
		"106(1), pp. 25-57, 2006 (As Research Report RC 23149, IBM \n"
		"T. J. Watson \n"
		"Research Center, Yorktown, USA\n"
		"\n"
		"Caveats:\n"
		"with default options, multipliers for the decision variables are \n"
		"wrong\n"
		" for equality constraints. Change the 'fixed_variable_treatment' to \n"
		"\n"
		"'make_constraint' or 'relax_bounds' to obtain correct results.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21y\n"
		"\n"
		">List of available options\n"
		"\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"|            Id            |    Type     |           Description           |\n"
		"+==========================+=============+=================================+\n"
		"| clip_inactive_lam        | OT_BOOL     | Explicitly set Lagrange         |\n"
		"|                          |             | multipliers to 0 when bound is  |\n"
		"|                          |             | deemed inactive (default:       |\n"
		"|                          |             | false).                         |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| con_integer_md           | OT_DICT     | Integer metadata (a dictionary  |\n"
		"|                          |             | with lists of integers) about   |\n"
		"|                          |             | constraints to be passed to     |\n"
		"|                          |             | IPOPT                           |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| con_numeric_md           | OT_DICT     | Numeric metadata (a dictionary  |\n"
		"|                          |             | with lists of reals) about      |\n"
		"|                          |             | constraints to be passed to     |\n"
		"|                          |             | IPOPT                           |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| con_string_md            | OT_DICT     | String metadata (a dictionary   |\n"
		"|                          |             | with lists of strings) about    |\n"
		"|                          |             | constraints to be passed to     |\n"
		"|                          |             | IPOPT                           |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| convexify_margin         | OT_DOUBLE   | When using a convexification    |\n"
		"|                          |             | strategy, make sure that the    |\n"
		"|                          |             | smallest eigenvalue is at least |\n"
		"|                          |             | this (default: 1e-7).           |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| convexify_strategy       | OT_STRING   | NONE|regularize|eigen-          |\n"
		"|                          |             | reflect|eigen-clip. Strategy to |\n"
		"|                          |             | convexify the Lagrange Hessian  |\n"
		"|                          |             | before passing it to the        |\n"
		"|                          |             | solver.                         |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| grad_f                   | OT_FUNCTION | Function for calculating the    |\n"
		"|                          |             | gradient of the objective       |\n"
		"|                          |             | (column, autogenerated by       |\n"
		"|                          |             | default)                        |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| hess_lag                 | OT_FUNCTION | Function for calculating the    |\n"
		"|                          |             | Hessian of the Lagrangian       |\n"
		"|                          |             | (autogenerated by default)      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| inactive_lam_strategy    | OT_STRING   | Strategy to detect if a bound   |\n"
		"|                          |             | is inactive. RELTOL: use        |\n"
		"|                          |             | solver-defined constraint       |\n"
		"|                          |             | tolerance *                     |\n"
		"|                          |             | inactive_lam_value|abstol: use  |\n"
		"|                          |             | inactive_lam_value              |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| inactive_lam_value       | OT_DOUBLE   | Value used in                   |\n"
		"|                          |             | inactive_lam_strategy (default: |\n"
		"|                          |             | 10).                            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| ipopt                    | OT_DICT     | Options to be passed to IPOPT   |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| jac_g                    | OT_FUNCTION | Function for calculating the    |\n"
		"|                          |             | Jacobian of the constraints     |\n"
		"|                          |             | (autogenerated by default)      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| max_iter_eig             | OT_DOUBLE   | Maximum number of iterations to |\n"
		"|                          |             | compute an eigenvalue           |\n"
		"|                          |             | decomposition (default: 50).    |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| pass_nonlinear_variables | OT_BOOL     | Pass list of variables entering |\n"
		"|                          |             | nonlinearly to IPOPT            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| var_integer_md           | OT_DICT     | Integer metadata (a dictionary  |\n"
		"|                          |             | with lists of integers) about   |\n"
		"|                          |             | variables to be passed to IPOPT |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| var_numeric_md           | OT_DICT     | Numeric metadata (a dictionary  |\n"
		"|                          |             | with lists of reals) about      |\n"
		"|                          |             | variables to be passed to IPOPT |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| var_string_md            | OT_DICT     | String metadata (a dictionary   |\n"
		"|                          |             | with lists of strings) about    |\n"
		"|                          |             | variables to be passed to IPOPT |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"knitro\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"KNITRO interface\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22c\n"
		"\n"
		">List of available options\n"
		"\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"|            Id            |        Type        |       Description        |\n"
		"+==========================+====================+==========================+\n"
		"| complem_variables        | OT_INTVECTORVECTOR | List of complementary    |\n"
		"|                          |                    | constraints on simple    |\n"
		"|                          |                    | bounds. Pair (i, j)      |\n"
		"|                          |                    | encodes complementarity  |\n"
		"|                          |                    | between the bounds on    |\n"
		"|                          |                    | variable i and variable  |\n"
		"|                          |                    | j.                       |\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"| contype                  | OT_INTVECTOR       | Type of constraint       |\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"| detect_linear_constraint | OT_BOOL            | Detect type of           |\n"
		"| s                        |                    | constraints              |\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"| knitro                   | OT_DICT            | Options to be passed to  |\n"
		"|                          |                    | KNITRO                   |\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"| options_file             | OT_STRING          | Read options from file   |\n"
		"|                          |                    | (solver specific)        |\n"
		"+--------------------------+--------------------+--------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"snopt\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"SNOPT interface\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22m\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------+-----------+---------------------------------------------+\n"
		"|  Id   |   Type    |                 Description                 |\n"
		"+=======+===========+=============================================+\n"
		"| snopt | OT_DICT   | Options to be passed to SNOPT               |\n"
		"+-------+-----------+---------------------------------------------+\n"
		"| start | OT_STRING | Warm-start options for Worhp: cold|warm|hot |\n"
		"+-------+-----------+---------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"worhp\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"WORHP interface\n"
		"\n"
		"Designed for Worhp 1.12\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------+---------+-------------------------------+\n"
		"|  Id   |  Type   |          Description          |\n"
		"+=======+=========+===============================+\n"
		"| worhp | OT_DICT | Options to be passed to WORHP |\n"
		"+-------+---------+-------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"feasiblesqpmethod\n"
		"-----------------\n"
		"\n"
		"\n"
		"\n"
		"A textbook FeasibleSQPMethod\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_241\n"
		"\n"
		">List of available options\n"
		"\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"|             Id             |      Type       |        Description        |\n"
		"+============================+=================+===========================+\n"
		"| anderson_memory            | OT_INT          | Anderson memory. If       |\n"
		"|                            |                 | Anderson is used default  |\n"
		"|                            |                 | is 1, else default is 0.  |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| contraction_acceptance_val | OT_DOUBLE       | If the empirical          |\n"
		"| ue                         |                 | contraction rate in the   |\n"
		"|                            |                 | feasibility iterations is |\n"
		"|                            |                 | above this value in the   |\n"
		"|                            |                 | heuristics the iterations |\n"
		"|                            |                 | are aborted.              |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| convexify_margin           | OT_DOUBLE       | When using a              |\n"
		"|                            |                 | convexification strategy, |\n"
		"|                            |                 | make sure that the        |\n"
		"|                            |                 | smallest eigenvalue4 is   |\n"
		"|                            |                 | at least this (default:   |\n"
		"|                            |                 | 1e-7).                    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| convexify_strategy         | OT_STRING       | NONE|regularize|eigen-    |\n"
		"|                            |                 | reflect|eigen-clip.       |\n"
		"|                            |                 | Strategy to convexify the |\n"
		"|                            |                 | Lagrange Hessian before   |\n"
		"|                            |                 | passing it to the solver. |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| f                          | OT_FUNCTION     | Function for calculating  |\n"
		"|                            |                 | the objective function    |\n"
		"|                            |                 | (autogenerated by         |\n"
		"|                            |                 | default)                  |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| feas_tol                   | OT_DOUBLE       | Feasibility tolerance.    |\n"
		"|                            |                 | Below this tolerance an   |\n"
		"|                            |                 | iterate is considered to  |\n"
		"|                            |                 | be feasible.              |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| g                          | OT_FUNCTION     | Function for calculating  |\n"
		"|                            |                 | the constraints           |\n"
		"|                            |                 | (autogenerated by         |\n"
		"|                            |                 | default)                  |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| grad_f                     | OT_FUNCTION     | Function for calculating  |\n"
		"|                            |                 | the gradient of the       |\n"
		"|                            |                 | objective (autogenerated  |\n"
		"|                            |                 | by default)               |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| hess_lag                   | OT_FUNCTION     | Function for calculating  |\n"
		"|                            |                 | the Hessian of the        |\n"
		"|                            |                 | Lagrangian (autogenerated |\n"
		"|                            |                 | by default)               |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| hessian_approximation      | OT_STRING       | limited-memory|exact      |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| init_feasible              | OT_BOOL         | Initialize the QP         |\n"
		"|                            |                 | subproblems with a        |\n"
		"|                            |                 | feasible initial value    |\n"
		"|                            |                 | (default: false).         |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| jac_g                      | OT_FUNCTION     | Function for calculating  |\n"
		"|                            |                 | the Jacobian of the       |\n"
		"|                            |                 | constraints               |\n"
		"|                            |                 | (autogenerated by         |\n"
		"|                            |                 | default)                  |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| lbfgs_memory               | OT_INT          | Size of L-BFGS memory.    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| max_inner_iter             | OT_DOUBLE       | Maximum number of inner   |\n"
		"|                            |                 | iterations.               |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| max_iter                   | OT_INT          | Maximum number of SQP     |\n"
		"|                            |                 | iterations                |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| max_iter_eig               | OT_DOUBLE       | Maximum number of         |\n"
		"|                            |                 | iterations to compute an  |\n"
		"|                            |                 | eigenvalue decomposition  |\n"
		"|                            |                 | (default: 50).            |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| merit_memory               | OT_INT          | Size of memory to store   |\n"
		"|                            |                 | history of merit function |\n"
		"|                            |                 | values                    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| min_iter                   | OT_INT          | Minimum number of SQP     |\n"
		"|                            |                 | iterations                |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| optim_tol                  | OT_DOUBLE       | Optimality tolerance.     |\n"
		"|                            |                 | Below this value an       |\n"
		"|                            |                 | iterate is considered to  |\n"
		"|                            |                 | be optimal.               |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| print_header               | OT_BOOL         | Print the header with     |\n"
		"|                            |                 | problem statistics        |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| print_iteration            | OT_BOOL         | Print the iterations      |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| print_status               | OT_BOOL         | Print a status message    |\n"
		"|                            |                 | after solving             |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| qpsol                      | OT_STRING       | The QP solver to be used  |\n"
		"|                            |                 | by the SQP method         |\n"
		"|                            |                 | [qpoases]                 |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| qpsol_options              | OT_DICT         | Options to be passed to   |\n"
		"|                            |                 | the QP solver             |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| solve_type                 | OT_STRING       | The solver type: Either   |\n"
		"|                            |                 | SQP or SLP. Defaults to   |\n"
		"|                            |                 | SQP                       |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tol_du                     | OT_DOUBLE       | Stopping criterion for    |\n"
		"|                            |                 | dual infeasability        |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tol_pr                     | OT_DOUBLE       | Stopping criterion for    |\n"
		"|                            |                 | primal infeasibility      |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_acceptance              | OT_DOUBLE       | Is the trust-region ratio |\n"
		"|                            |                 | above this value, the     |\n"
		"|                            |                 | step is accepted.         |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_alpha1                  | OT_DOUBLE       | Lower alpha in trust-     |\n"
		"|                            |                 | region size criterion.    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_alpha2                  | OT_DOUBLE       | Upper alpha in trust-     |\n"
		"|                            |                 | region size criterion.    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_eta1                    | OT_DOUBLE       | Lower eta in trust-region |\n"
		"|                            |                 | acceptance criterion.     |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_eta2                    | OT_DOUBLE       | Upper eta in trust-region |\n"
		"|                            |                 | acceptance criterion.     |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_rad0                    | OT_DOUBLE       | Initial trust-region      |\n"
		"|                            |                 | radius.                   |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_rad_max                 | OT_DOUBLE       | Maximum trust-region      |\n"
		"|                            |                 | radius.                   |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_rad_min                 | OT_DOUBLE       | Minimum trust-region      |\n"
		"|                            |                 | radius.                   |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_scale_vector            | OT_DOUBLEVECTOR | Vector that tells where   |\n"
		"|                            |                 | trust-region is applied.  |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| tr_tol                     | OT_DOUBLE       | Trust-region tolerance.   |\n"
		"|                            |                 | Below this value another  |\n"
		"|                            |                 | scalar is equal to the    |\n"
		"|                            |                 | trust region radius.      |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| use_anderson               | OT_BOOL         | Use Anderson              |\n"
		"|                            |                 | Acceleration. (default    |\n"
		"|                            |                 | false)                    |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"| watchdog                   | OT_INT          | Number of watchdog        |\n"
		"|                            |                 | iterations in feasibility |\n"
		"|                            |                 | iterations. After this    |\n"
		"|                            |                 | amount of iterations, it  |\n"
		"|                            |                 | is checked with the       |\n"
		"|                            |                 | contraction acceptance    |\n"
		"|                            |                 | value, if iterations are  |\n"
		"|                            |                 | converging.               |\n"
		"+----------------------------+-----------------+---------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"qrsqp\n"
		"-----\n"
		"\n"
		"\n"
		"\n"
		"A textbook SQPMethod\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22u\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"scpgen\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"A structure-exploiting sequential quadratic programming (to be come \n"
		"\n"
		"sequential convex programming) method for nonlinear programming.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_232\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"|          Id           |      Type       |          Description           |\n"
		"+=======================+=================+================================+\n"
		"| beta                  | OT_DOUBLE       | Line-search parameter,         |\n"
		"|                       |                 | restoration factor of stepsize |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| c1                    | OT_DOUBLE       | Armijo condition, coefficient  |\n"
		"|                       |                 | of decrease in merit           |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| codegen               | OT_BOOL         | C-code generation              |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| hessian_approximation | OT_STRING       | gauss-newton|exact             |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| lbfgs_memory          | OT_INT          | Size of L-BFGS memory.         |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| max_iter              | OT_INT          | Maximum number of SQP          |\n"
		"|                       |                 | iterations                     |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| max_iter_ls           | OT_INT          | Maximum number of linesearch   |\n"
		"|                       |                 | iterations                     |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| merit_memsize         | OT_INT          | Size of memory to store        |\n"
		"|                       |                 | history of merit function      |\n"
		"|                       |                 | values                         |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| merit_start           | OT_DOUBLE       | Lower bound for the merit      |\n"
		"|                       |                 | function parameter             |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| name_x                | OT_STRINGVECTOR | Names of the variables.        |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| print_header          | OT_BOOL         | Print the header with problem  |\n"
		"|                       |                 | statistics                     |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| print_x               | OT_INTVECTOR    | Which variables to print.      |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| qpsol                 | OT_STRING       | The QP solver to be used by    |\n"
		"|                       |                 | the SQP method                 |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| qpsol_options         | OT_DICT         | Options to be passed to the QP |\n"
		"|                       |                 | solver                         |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| reg_threshold         | OT_DOUBLE       | Threshold for the              |\n"
		"|                       |                 | regularization.                |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| regularize            | OT_BOOL         | Automatic regularization of    |\n"
		"|                       |                 | Lagrange Hessian.              |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| tol_du                | OT_DOUBLE       | Stopping criterion for dual    |\n"
		"|                       |                 | infeasability                  |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| tol_pr                | OT_DOUBLE       | Stopping criterion for primal  |\n"
		"|                       |                 | infeasibility                  |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| tol_pr_step           | OT_DOUBLE       | Stopping criterion for the     |\n"
		"|                       |                 | step size                      |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"| tol_reg               | OT_DOUBLE       | Stopping criterion for         |\n"
		"|                       |                 | regularization                 |\n"
		"+-----------------------+-----------------+--------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"sqpmethod\n"
		"---------\n"
		"\n"
		"\n"
		"\n"
		"A textbook SQPMethod\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22x\n"
		"\n"
		">List of available options\n"
		"\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"|            Id            |    Type     |           Description           |\n"
		"+==========================+=============+=================================+\n"
		"| beta                     | OT_DOUBLE   | Line-search parameter,          |\n"
		"|                          |             | restoration factor of stepsize  |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| c1                       | OT_DOUBLE   | Armijo condition, coefficient   |\n"
		"|                          |             | of decrease in merit            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| convexify_margin         | OT_DOUBLE   | When using a convexification    |\n"
		"|                          |             | strategy, make sure that the    |\n"
		"|                          |             | smallest eigenvalue is at least |\n"
		"|                          |             | this (default: 1e-7).           |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| convexify_strategy       | OT_STRING   | NONE|regularize|eigen-          |\n"
		"|                          |             | reflect|eigen-clip. Strategy to |\n"
		"|                          |             | convexify the Lagrange Hessian  |\n"
		"|                          |             | before passing it to the        |\n"
		"|                          |             | solver.                         |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| elastic_mode             | OT_BOOL     | Enable the elastic mode which   |\n"
		"|                          |             | is used when the QP is          |\n"
		"|                          |             | infeasible (default: false).    |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| gamma_0                  | OT_DOUBLE   | Starting value for the penalty  |\n"
		"|                          |             | parameter of elastic mode       |\n"
		"|                          |             | (default: 1).                   |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| gamma_1_min              | OT_DOUBLE   | Minimum value for gamma_1       |\n"
		"|                          |             | (default: 1e-5).                |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| gamma_max                | OT_DOUBLE   | Maximum value for the penalty   |\n"
		"|                          |             | parameter of elastic mode       |\n"
		"|                          |             | (default: 1e20).                |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| hess_lag                 | OT_FUNCTION | Function for calculating the    |\n"
		"|                          |             | Hessian of the Lagrangian       |\n"
		"|                          |             | (autogenerated by default)      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| hessian_approximation    | OT_STRING   | limited-memory|exact            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| init_feasible            | OT_BOOL     | Initialize the QP subproblems   |\n"
		"|                          |             | with a feasible initial value   |\n"
		"|                          |             | (default: false).               |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| jac_fg                   | OT_FUNCTION | Function for calculating the    |\n"
		"|                          |             | gradient of the objective and   |\n"
		"|                          |             | Jacobian of the constraints     |\n"
		"|                          |             | (autogenerated by default)      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| lbfgs_memory             | OT_INT      | Size of L-BFGS memory.          |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| max_iter                 | OT_INT      | Maximum number of SQP           |\n"
		"|                          |             | iterations                      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| max_iter_eig             | OT_DOUBLE   | Maximum number of iterations to |\n"
		"|                          |             | compute an eigenvalue           |\n"
		"|                          |             | decomposition (default: 50).    |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| max_iter_ls              | OT_INT      | Maximum number of linesearch    |\n"
		"|                          |             | iterations                      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| merit_memory             | OT_INT      | Size of memory to store history |\n"
		"|                          |             | of merit function values        |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| min_iter                 | OT_INT      | Minimum number of SQP           |\n"
		"|                          |             | iterations                      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| min_step_size            | OT_DOUBLE   | The size (inf-norm) of the step |\n"
		"|                          |             | size should not become smaller  |\n"
		"|                          |             | than this.                      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| print_header             | OT_BOOL     | Print the header with problem   |\n"
		"|                          |             | statistics                      |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| print_iteration          | OT_BOOL     | Print the iterations            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| print_status             | OT_BOOL     | Print a status message after    |\n"
		"|                          |             | solving                         |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| qpsol                    | OT_STRING   | The QP solver to be used by the |\n"
		"|                          |             | SQP method [qpoases]            |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| qpsol_options            | OT_DICT     | Options to be passed to the QP  |\n"
		"|                          |             | solver                          |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| second_order_corrections | OT_BOOL     | Enable second order             |\n"
		"|                          |             | corrections. These are used     |\n"
		"|                          |             | when a step is considered bad   |\n"
		"|                          |             | by the merit function and       |\n"
		"|                          |             | constraint norm (default:       |\n"
		"|                          |             | false).                         |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| tol_du                   | OT_DOUBLE   | Stopping criterion for dual     |\n"
		"|                          |             | infeasability                   |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"| tol_pr                   | OT_DOUBLE   | Stopping criterion for primal   |\n"
		"|                          |             | infeasibility                   |\n"
		"+--------------------------+-------------+---------------------------------+\n"
		"\n"
		"Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L115\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L115-L118\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol(str name, str solver, Importer compiler, dict opts)\n"
		"  nlpsol(str name, str solver, NlpBuilder nl, dict opts)\n"
		"  nlpsol(str name, str solver, dict:MX nlp, dict opts)\n"
		"  nlpsol(str name, str solver, str fname, dict opts)\n"
		"  nlpsol(str name, str solver, Function nlp, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_in", _wrap_nlpsol_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_in() -> [str]\n"
		"  nlpsol_in(int ind) -> str\n"
		"\n"
		"Get input scheme of NLP solvers.\n"
		"\n"
		">Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)\n"
		"\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"|   Full name   | Short  |                   Description                   |\n"
		"+===============+========+=================================================+\n"
		"| NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |\n"
		"|               |        | default -inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |\n"
		"|               |        | default +inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |\n"
		"|               |        | guess (nx x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |\n"
		"|               |        | guess (ng x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L197\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L197-L201\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme of NLP solvers.\n"
		"\n"
		">Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)\n"
		"\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"|   Full name   | Short  |                   Description                   |\n"
		"+===============+========+=================================================+\n"
		"| NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |\n"
		"|               |        | default -inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |\n"
		"|               |        | default +inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |\n"
		"|               |        | guess (nx x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |\n"
		"|               |        | guess (ng x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sy\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L197\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L197-L201\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get NLP solver input scheme name by index.\n"
		"\n"
		">Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)\n"
		"\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"|   Full name   | Short  |                   Description                   |\n"
		"+===============+========+=================================================+\n"
		"| NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |\n"
		"|               |        | default -inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |\n"
		"|               |        | default +inf.                                   |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |\n"
		"|               |        | guess (nx x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"| NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |\n"
		"|               |        | guess (ng x 1)                                  |\n"
		"+---------------+--------+-------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L228\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L228-L241\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_out", _wrap_nlpsol_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_out() -> [str]\n"
		"  nlpsol_out(int ind) -> str\n"
		"\n"
		"Get NLP solver output scheme of NLP solvers.\n"
		"\n"
		">Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)\n"
		"\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"|  Full name   | Short |                    Description                    |\n"
		"+==============+=======+===================================================+\n"
		"| NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |\n"
		"|              |       | x 1)                                              |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |\n"
		"|              |       | solution (nx x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |\n"
		"|              |       | solution (ng x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |\n"
		"|              |       | solution (np x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L203\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L203-L207\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get NLP solver output scheme of NLP solvers.\n"
		"\n"
		">Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)\n"
		"\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"|  Full name   | Short |                    Description                    |\n"
		"+==============+=======+===================================================+\n"
		"| NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |\n"
		"|              |       | x 1)                                              |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |\n"
		"|              |       | solution (nx x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |\n"
		"|              |       | solution (ng x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |\n"
		"|              |       | solution (np x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L203\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L203-L207\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme name by index.\n"
		"\n"
		">Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)\n"
		"\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"|  Full name   | Short |                    Description                    |\n"
		"+==============+=======+===================================================+\n"
		"| NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |\n"
		"|              |       | 1)                                                |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |\n"
		"|              |       | x 1)                                              |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |\n"
		"|              |       | solution (nx x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |\n"
		"|              |       | solution (ng x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"| NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |\n"
		"|              |       | solution (np x 1)                                 |\n"
		"+--------------+-------+---------------------------------------------------+\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L243\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L243-L254\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_n_in", (PyCFunction)_wrap_nlpsol_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_n_in() -> int\n"
		"\n"
		"Number of NLP solver inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L256\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L256-L258\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_n_out", (PyCFunction)_wrap_nlpsol_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_n_out() -> int\n"
		"\n"
		"Number of NLP solver outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L260\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L260-L262\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_default_in", _wrap_nlpsol_default_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_default_in() -> [float]\n"
		"  nlpsol_default_in(int ind) -> float\n"
		"\n"
		"Default input for an NLP solver.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L209\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L209-L220\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_default_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default input for an NLP solver.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L222\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L222-L226\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_default_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default input for an NLP solver.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L209\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L209-L220\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_options", (PyCFunction)_wrap_nlpsol_options, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_options(str name) -> [str]\n"
		"\n"
		"Get all options for a plugin.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L801\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L801-L803\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_option_type", _wrap_nlpsol_option_type, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_option_type(str name, str op) -> str\n"
		"\n"
		"Get type info for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L805\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L805-L807\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nlpsol_option_info", _wrap_nlpsol_option_info, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nlpsol_option_info(str name, str op) -> str\n"
		"\n"
		"Get documentation for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L809\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L809-L811\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_nlpsol", (PyCFunction)_wrap_has_nlpsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_nlpsol(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L34\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L34-L36\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_nlpsol", (PyCFunction)_wrap_load_nlpsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_nlpsol(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L38\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L38-L40\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_nlpsol", (PyCFunction)_wrap_doc_nlpsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_nlpsol(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.hpp#L42\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlpsol.cpp#L42-L44\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder", _wrap_rootfinder, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder(str name, str solver, dict:SX rfp, dict opts) -> Function\n"
		"  rootfinder(str name, str solver, dict:MX rfp, dict opts) -> Function\n"
		"  rootfinder(str name, str solver, Function f, dict opts) -> Function\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder(str name, str solver, dict:SX rfp, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL]\n"
		"\n"
		"Create a solver for rootfinding problems Takes a function where one \n"
		"of the \n"
		"inputs is unknown and one of the outputs is a residual function\n"
		" that is \n"
		"always zero, defines a new function where the the unknown \n"
		"input has been \n"
		"replaced by a  guess for the unknown and the residual output has been \n"
		"replaced by the \n"
		"calculated value for the input.\n"
		"\n"
		"For a function [y0, y1, ...,yi, .., yn] = F(x0, x1, ..., xj, ..., xm),\n"
		"\n"
		"where xj is unknown and yi=0, defines a new function [y0, y1, ...,xj,\n"
		" .., \n"
		"yn] = G(x0, x1, ..., xj_guess, ..., xm),\n"
		"\n"
		"xj and yi must have the same dimension and d(yi)/d(xj) must be \n"
		"invertable.\n"
		"\n"
		"By default, the first input is unknown and the first output is the \n"
		"\n"
		"residual.\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| common_options   | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | auto-generated   | nction           |\n"
		"|                  |                 | functions        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| constraints      | OT_INTVECTOR    | Constrain the    | casadi::Rootfind |\n"
		"|                  |                 | unknowns. 0      | er               |\n"
		"|                  |                 | (default): no    |                  |\n"
		"|                  |                 | constraint on    |                  |\n"
		"|                  |                 | ui, 1: ui >=     |                  |\n"
		"|                  |                 | 0.0, -1: ui <=   |                  |\n"
		"|                  |                 | 0.0, 2: ui >     |                  |\n"
		"|                  |                 | 0.0, -2: ui <    |                  |\n"
		"|                  |                 | 0.0.             |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |\n"
		"|                  |                 | SX expressions   | nction           |\n"
		"|                  |                 | in problem       |                  |\n"
		"|                  |                 | formulation      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| implicit_input   | OT_INT          | Index of the     | casadi::Rootfind |\n"
		"|                  |                 | input that       | er               |\n"
		"|                  |                 | corresponds to   |                  |\n"
		"|                  |                 | the actual root- |                  |\n"
		"|                  |                 | finding          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| implicit_output  | OT_INT          | Index of the     | casadi::Rootfind |\n"
		"|                  |                 | output that      | er               |\n"
		"|                  |                 | corresponds to   |                  |\n"
		"|                  |                 | the actual root- |                  |\n"
		"|                  |                 | finding          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_functio | OT_FUNCTION     | Function object  | casadi::Rootfind |\n"
		"| n                |                 | for calculating  | er               |\n"
		"|                  |                 | the Jacobian     |                  |\n"
		"|                  |                 | (autogenerated   |                  |\n"
		"|                  |                 | by default)      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| linear_solver    | OT_STRING       | User-defined     | casadi::Rootfind |\n"
		"|                  |                 | linear solver    | er               |\n"
		"|                  |                 | class. Needed    |                  |\n"
		"|                  |                 | for              |                  |\n"
		"|                  |                 | sensitivities.   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| linear_solver_op | OT_DICT         | Options to be    | casadi::Rootfind |\n"
		"| tions            |                 | passed to the    | er               |\n"
		"|                  |                 | linear solver.   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |\n"
		"|                  |                 | problem          | nction           |\n"
		"|                  |                 | functions to be  |                  |\n"
		"|                  |                 | monitored        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |\n"
		"| gs               |                 | generated from   | nction           |\n"
		"|                  |                 | function         |                  |\n"
		"|                  |                 | evaluations      |                  |\n"
		"|                  |                 | [true]           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| specific_options | OT_DICT         | Options for      | casadi::OracleFu |\n"
		"|                  |                 | specific auto-   | nction           |\n"
		"|                  |                 | generated        |                  |\n"
		"|                  |                 | functions,       |                  |\n"
		"|                  |                 | overwriting the  |                  |\n"
		"|                  |                 | defaults from    |                  |\n"
		"|                  |                 | common_options.  |                  |\n"
		"|                  |                 | Nested           |                  |\n"
		"|                  |                 | dictionary.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		">Input scheme: casadi::RootfinderInput (ROOTFINDER_NUM_IN = 2)\n"
		"\n"
		"+---------------+-------+---------------------------------+\n"
		"|   Full name   | Short |           Description           |\n"
		"+===============+=======+=================================+\n"
		"| ROOTFINDER_X0 | x0    | Initial guess for the solution. |\n"
		"+---------------+-------+---------------------------------+\n"
		"| ROOTFINDER_P  | p     | Parameters.                     |\n"
		"+---------------+-------+---------------------------------+\n"
		"\n"
		">Output scheme: casadi::RootfinderOutput (ROOTFINDER_NUM_OUT = 1)\n"
		"\n"
		"+--------------+-------+--------------------------------------+\n"
		"|  Full name   | Short |             Description              |\n"
		"+==============+=======+======================================+\n"
		"| ROOTFINDER_X | x     | Solution to the system of equations. |\n"
		"+--------------+-------+--------------------------------------+\n"
		"\n"
		"List of plugins\n"
		"- kinsol\n"
		"\n"
		"- fast_newton\n"
		"\n"
		"- nlpsol\n"
		"\n"
		"- newton\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Rootfinder.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"kinsol\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"KINSOL interface from the Sundials suite\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_226\n"
		"\n"
		">List of available options\n"
		"\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"|            Id             |      Type       |        Description         |\n"
		"+===========================+=================+============================+\n"
		"| abstol                    | OT_DOUBLE       | Stopping criterion         |\n"
		"|                           |                 | tolerance                  |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| disable_internal_warnings | OT_BOOL         | Disable KINSOL internal    |\n"
		"|                           |                 | warning messages           |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| exact_jacobian            | OT_BOOL         | Use exact Jacobian         |\n"
		"|                           |                 | information                |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| f_scale                   | OT_DOUBLEVECTOR | Equation scaling factors   |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| iterative_solver          | OT_STRING       | gmres|bcgstab|tfqmr        |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| linear_solver_type        | OT_STRING       | dense|banded|iterative|use |\n"
		"|                           |                 | r_defined                  |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| lower_bandwidth           | OT_INT          | Lower bandwidth for banded |\n"
		"|                           |                 | linear solvers             |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_iter                  | OT_INT          | Maximum number of Newton   |\n"
		"|                           |                 | iterations. Putting 0 sets |\n"
		"|                           |                 | the default value of       |\n"
		"|                           |                 | KinSol.                    |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| max_krylov                | OT_INT          | Maximum Krylov space       |\n"
		"|                           |                 | dimension                  |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| pretype                   | OT_STRING       | Type of preconditioner     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| print_level               | OT_INT          | Verbosity level            |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| strategy                  | OT_STRING       | Globalization strategy     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| u_scale                   | OT_DOUBLEVECTOR | Variable scaling factors   |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| upper_bandwidth           | OT_INT          | Upper bandwidth for banded |\n"
		"|                           |                 | linear solvers             |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"| use_preconditioner        | OT_BOOL         | Precondition an iterative  |\n"
		"|                           |                 | solver                     |\n"
		"+---------------------------+-----------------+----------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"fast_newton\n"
		"-----------\n"
		"\n"
		"\n"
		"\n"
		"Implements simple newton iterations to solve an implicit function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_237\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------+-----------+-------------------------------------------------+\n"
		"|     Id     |   Type    |                   Description                   |\n"
		"+============+===========+=================================================+\n"
		"| abstol     | OT_DOUBLE | Stopping criterion tolerance on ||g||__inf)     |\n"
		"+------------+-----------+-------------------------------------------------+\n"
		"| abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size       |\n"
		"+------------+-----------+-------------------------------------------------+\n"
		"| max_iter   | OT_INT    | Maximum number of Newton iterations to perform  |\n"
		"|            |           | before returning.                               |\n"
		"+------------+-----------+-------------------------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"nlpsol\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"newton\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Implements simple newton iterations to solve an implicit function.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_236\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"|       Id        |   Type    |                Description                 |\n"
		"+=================+===========+============================================+\n"
		"| abstol          | OT_DOUBLE | Stopping criterion tolerance on max(|F|)   |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| abstolStep      | OT_DOUBLE | Stopping criterion tolerance on step size  |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| line_search     | OT_BOOL   | Enable line-search (default: true)         |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| max_iter        | OT_INT    | Maximum number of Newton iterations to     |\n"
		"|                 |           | perform before returning.                  |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"| print_iteration | OT_BOOL   | Print information about each iteration     |\n"
		"+-----------------+-----------+--------------------------------------------+\n"
		"\n"
		"Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L96\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L96-L99\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder(str name, str solver, dict:MX rfp, dict opts)\n"
		"  rootfinder(str name, str solver, Function f, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_in", _wrap_rootfinder_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_in() -> [str]\n"
		"  rootfinder_in(int ind) -> str\n"
		"\n"
		"Get rootfinder input scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ty\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L35\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L35-L39\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get rootfinder input scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ty\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L35\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L35-L39\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get rootfinder input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L47\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L47-L54\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_out", _wrap_rootfinder_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_out() -> [str]\n"
		"  rootfinder_out(int ind) -> str\n"
		"\n"
		"Get rootfinder output scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1tz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L41\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L41-L45\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get rootfinder output scheme.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1tz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L41\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L41-L45\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get rootfinder output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L56\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L56-L62\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_n_in", (PyCFunction)_wrap_rootfinder_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_n_in() -> int\n"
		"\n"
		"Number of rootfinder inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L64\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L64-L66\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_n_out", (PyCFunction)_wrap_rootfinder_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_n_out() -> int\n"
		"\n"
		"Number of rootfinder outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L68\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L68-L70\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_options", (PyCFunction)_wrap_rootfinder_options, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_options(str name) -> [str]\n"
		"\n"
		"Get all options for a plugin.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L72\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L72-L74\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_option_type", _wrap_rootfinder_option_type, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_option_type(str name, str op) -> str\n"
		"\n"
		"Get type info for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L76\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L76-L78\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rootfinder_option_info", _wrap_rootfinder_option_info, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rootfinder_option_info(str name, str op) -> str\n"
		"\n"
		"Get documentation for a particular option.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L80\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L80-L82\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_rootfinder", (PyCFunction)_wrap_has_rootfinder, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_rootfinder(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L84\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L84-L86\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_rootfinder", (PyCFunction)_wrap_load_rootfinder, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_rootfinder(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L88\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L88-L90\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_rootfinder", (PyCFunction)_wrap_doc_rootfinder, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_rootfinder(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.hpp#L92\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/rootfinder.cpp#L92-L94\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_type_name", (PyCFunction)_wrap_Linsol_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_has_plugin", (PyCFunction)_wrap_Linsol_has_plugin, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_plugin(str name) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_load_plugin", (PyCFunction)_wrap_Linsol_load_plugin, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  load_plugin(str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_doc", (PyCFunction)_wrap_Linsol_doc, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  doc(str name) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_plugin_name", (PyCFunction)_wrap_Linsol_plugin_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  plugin_name(self) -> str\n"
		"\n"
		"Query plugin name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L97\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L64-L66\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_sparsity", (PyCFunction)_wrap_Linsol_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sparsity(self) -> Sparsity\n"
		"\n"
		"Get linear system sparsity.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L100\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L68-L70\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_sfact", _wrap_Linsol_sfact, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sfact(self, DM A)\n"
		"\n"
		"Symbolic factorization of the linear system, e.g. selecting \n"
		"pivots.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L103\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L104-L107\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_nfact", _wrap_Linsol_nfact, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nfact(self, DM A)\n"
		"\n"
		"Numeric factorization of the linear system.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L106\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L126-L129\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_solve", _wrap_Linsol_solve, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solve(self, DM A, DM B, bool tr) -> DM\n"
		"  solve(self, MX A, MX B, bool tr) -> MX\n"
		"\n"
		" Solve linear system of equations\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L110\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L72-L98\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  solve(self, DM A, DM B, bool tr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		" Solve linear system of equations\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L110\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L72-L98\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  solve(self, MX A, MX B, bool tr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		" Solve linear system of equations\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L111\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L100-L102\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_neig", _wrap_Linsol_neig, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  neig(self, DM A) -> int\n"
		"\n"
		"Number of negative eigenvalues.\n"
		"\n"
		"Not available for all solvers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1kk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L119\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L165-L170\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_rank", _wrap_Linsol_rank, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  rank(self, DM A) -> int\n"
		"\n"
		" Matrix rank.\n"
		"\n"
		"Not available for all solvers\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1kl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L126\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L176-L181\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_stats", _wrap_Linsol_stats, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  stats(self, int mem) -> dict\n"
		"\n"
		"Get all statistics obtained at the end of the last evaluate \n"
		"call.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L129\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L217-L219\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Linsol", _wrap_new_Linsol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Linsol()\n"
		"  Linsol(Linsol other)\n"
		"  Linsol(str name, str solver, Sparsity sp, dict opts)\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L66\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L34-L38\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Linsol(Linsol other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Linsol()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L63\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L31-L32\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Linsol(str name, str solver, Sparsity sp, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L66\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L34-L38\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Linsol", (PyCFunction)_wrap_delete_Linsol, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Linsol(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Linsol_swigregister", Linsol_swigregister, METH_VARARGS, NULL},
	 { (char *)"has_linsol", (PyCFunction)_wrap_has_linsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_linsol(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L205\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L205-L207\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_linsol", (PyCFunction)_wrap_load_linsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_linsol(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L209\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L209-L211\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_linsol", (PyCFunction)_wrap_doc_linsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_linsol(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.hpp#L213\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/linsol.cpp#L213-L215\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dplesol", _wrap_dplesol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dplesol([DM] A, [DM] V, str solver, dict opts) -> [DM]\n"
		"  dplesol(MX A, MX V, str solver, dict opts) -> MX\n"
		"  dplesol([MX] A, [MX] V, str solver, dict opts) -> [MX]\n"
		"  dplesol(str name, str solver, dict:Sparsity st, dict opts) -> Function\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dplesol([DM] A, [DM] V, str solver, dict opts)\n"
		"  dplesol(MX A, MX V, str solver, dict opts)\n"
		"  dplesol([MX] A, [MX] V, str solver, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dplesol(str name, str solver, dict:Sparsity st, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL]\n"
		"\n"
		"Discrete periodic Lyapunov Equation solver Given matrices  $A_k$ and \n"
		"symmetric  $V_k, k = 0..K-1$\n"
		"\n"
		"::\n"
		"\n"
		"  A_k in R^(n x n)\n"
		"  V_k in R^n\n"
		"\n"
		"\n"
		"provides all of  $P_k$ that satisfy:\n"
		"\n"
		"::\n"
		"\n"
		"  P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k\n"
		"  P_k+1 = A_k*P_k*A_k' + V_k  for k = 1..K-1\n"
		"\n"
		"\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| const_dim        | OT_BOOL         | Assume constant  | casadi::Dple     |\n"
		"|                  |                 | dimension of P   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| eps_unstable     | OT_DOUBLE       | A margin for     | casadi::Dple     |\n"
		"|                  |                 | unstability      |                  |\n"
		"|                  |                 | detection        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_unstable   | OT_BOOL         | Throw an         | casadi::Dple     |\n"
		"|                  |                 | exception when   |                  |\n"
		"|                  |                 | it is detected   |                  |\n"
		"|                  |                 | that             |                  |\n"
		"|                  |                 | Product(A_i,     |                  |\n"
		"|                  |                 | i=N..1)has       |                  |\n"
		"|                  |                 | eigenvalues      |                  |\n"
		"|                  |                 | greater than     |                  |\n"
		"|                  |                 | 1-eps_unstable   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| pos_def          | OT_BOOL         | Assume P         | casadi::Dple     |\n"
		"|                  |                 | positive         |                  |\n"
		"|                  |                 | definite         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		">Input scheme: casadi::DpleInput (DPLE_NUM_IN = 2)\n"
		"\n"
		"+-----------+-------+------------------------------------------------------+\n"
		"| Full name | Short |                     Description                      |\n"
		"+===========+=======+======================================================+\n"
		"| DPLE_A    | a     | A matrices (horzcat when const_dim, diagcat          |\n"
		"|           |       | otherwise) [a].                                      |\n"
		"+-----------+-------+------------------------------------------------------+\n"
		"| DPLE_V    | v     | V matrices (horzcat when const_dim, diagcat          |\n"
		"|           |       | otherwise) [v].                                      |\n"
		"+-----------+-------+------------------------------------------------------+\n"
		"\n"
		">Output scheme: casadi::DpleOutput (DPLE_NUM_OUT = 1)\n"
		"\n"
		"+-----------+-------+------------------------------------------------------+\n"
		"| Full name | Short |                     Description                      |\n"
		"+===========+=======+======================================================+\n"
		"| DPLE_P    | p     | Lyapunov matrix (horzcat when const_dim, diagcat     |\n"
		"|           |       | otherwise) (Cholesky of P if pos_def) [p].           |\n"
		"+-----------+-------+------------------------------------------------------+\n"
		"\n"
		"List of plugins\n"
		"- slicot\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Dple.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"slicot\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"An efficient solver for Discrete Periodic Lyapunov Equations using \n"
		"SLICOT\n"
		"\n"
		"Uses Periodic Schur Decomposition ('psd') and does not assume positive\n"
		"\n"
		"definiteness. Based on Periodic Lyapunov equations: some applications\n"
		" and \n"
		"new algorithms. Int. J. Control, vol. 67, pp. 69-87, 1997.\n"
		"\n"
		"Overview of the method: J. Gillis Practical Methods for Approximate \n"
		"Robust \n"
		"Periodic Optimal Control ofNonlinear Mechanical Systems, PhD \n"
		"Thesis, \n"
		"KULeuven, 2015\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22j\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"|          Id           |   Type    |             Description              |\n"
		"+=======================+===========+======================================+\n"
		"| linear_solver         | OT_STRING | User-defined linear solver class.    |\n"
		"|                       |           | Needed for sensitivities.            |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| linear_solver_options | OT_DICT   | Options to be passed to the linear   |\n"
		"|                       |           | solver.                              |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"| psd_num_zero          | OT_DOUBLE | Numerical zero used in Periodic      |\n"
		"|                       |           | Schur decomposition with slicot.This |\n"
		"|                       |           | option is needed when your systems   |\n"
		"|                       |           | has Floquet multiplierszero or close |\n"
		"|                       |           | to zero                              |\n"
		"+-----------------------+-----------+--------------------------------------+\n"
		"\n"
		"Joris Gillis\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L97\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L97-L100\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dple_in", _wrap_dple_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dple_in() -> [str]\n"
		"  dple_in(int ind) -> str\n"
		"\n"
		"Get input scheme of DPLE solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L102\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L102-L106\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dple_in()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get input scheme of DPLE solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L102\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L102-L106\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dple_in(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get DPLE input scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ne\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L114\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L114-L121\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dple_out", _wrap_dple_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dple_out() -> [str]\n"
		"  dple_out(int ind) -> str\n"
		"\n"
		"Get output scheme of DPLE solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L108\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L108-L112\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dple_out(int ind)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get DPLE output scheme name by index.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L123\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L123-L129\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dple_out()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get output scheme of DPLE solvers.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L108\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L108-L112\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dple_n_in", (PyCFunction)_wrap_dple_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dple_n_in() -> int\n"
		"\n"
		"Get the number of QP solver inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ng\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L131\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L131-L133\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dple_n_out", (PyCFunction)_wrap_dple_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dple_n_out() -> int\n"
		"\n"
		"Get the number of QP solver outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1nh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L135\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L135-L137\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_dple", (PyCFunction)_wrap_has_dple, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_dple(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L31\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L31-L33\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_dple", (PyCFunction)_wrap_load_dple, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_dple(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L35\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L35-L37\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_dple", (PyCFunction)_wrap_doc_dple, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_dple(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.hpp#L39\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dple.cpp#L39-L41\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expmsol", _wrap_expmsol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL]\n"
		"\n"
		"::\n"
		"\n"
		"  expmsol(str name, str solver, Sparsity A, dict opts) -> Function\n"
		"\n"
		"\n"
		"Performs a matrix exponentiation expm(A)\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| const_A          | OT_BOOL         | Assume A is      | casadi::Expm     |\n"
		"|                  |                 | constant.        |                  |\n"
		"|                  |                 | Default: false.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		"List of plugins\n"
		"- slicot\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Expm.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"slicot\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_22l\n"
		"\n"
		"Joris Gillis\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L44\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L44-L47\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expm_n_in", (PyCFunction)_wrap_expm_n_in, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  expm_n_in() -> int\n"
		"\n"
		"Get the number of expm solver inputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L49\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L49-L51\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expm_n_out", (PyCFunction)_wrap_expm_n_out, METH_NOARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  expm_n_out() -> int\n"
		"\n"
		"Get the number of expm solver outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L53\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L53-L55\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_expm", (PyCFunction)_wrap_has_expm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_expm(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L32\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L32-L34\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_expm", (PyCFunction)_wrap_load_expm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_expm(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L36\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L36-L38\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_expm", (PyCFunction)_wrap_doc_expm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_expm(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.hpp#L40\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/expm.cpp#L40-L42\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"interpolant", _wrap_interpolant, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  interpolant(str name, str solver, [[float]] grid, int m, dict opts) -> Function\n"
		"  interpolant(str name, str solver, [int] grid_dims, int m, dict opts) -> Function\n"
		"  interpolant(str name, str solver, [[float]] grid, [float] values, dict opts) -> Function\n"
		"  interpolant(str name, str solver, [int] grid_dims, [float] values, dict opts) -> Function\n"
		"\n"
		"Parametric variant of interpolant.\n"
		"\n"
		"The resulting function will have additional arguments for the grid and\n"
		"\n"
		"coefficients\n"
		"\n"
		"By default, derivatives wrt the coefficients are not supported (zero).\n"
		" Some\n"
		" interpolant plugins may support the  inline=true which enables correct \n"
		"derivatives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L205\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L205-L213\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  interpolant(str name, str solver, [[float]] grid, [float] values, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL]\n"
		"\n"
		"An interpolant function for lookup table data\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"label for the resulting  Function\n"
		"\n"
		"solver: \n"
		"name of the plugin\n"
		"\n"
		"grid: \n"
		"collection of 1D grids whose outer product defines the full N-D \n"
		"\n"
		"rectangular grid\n"
		"\n"
		"values: \n"
		"flattened vector of all values for all gridpoints\n"
		"\n"
		"Syntax 1D\n"
		"\n"
		"::\n"
		"\n"
		"  * # Python\n"
		"  * xgrid = np.linspace(1,6,6)\n"
		"  * V = [-1,-1,-2,-3,0,2]\n"
		"  * LUT = casadi.interpolant(\"LUT\",\"bspline\",[xgrid],V)\n"
		"  * print(LUT(2.5))\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  * % Matlab\n"
		"  * xgrid = 1:6;\n"
		"  * V = [-1 -1 -2 -3 0 2];\n"
		"  * LUT = casadi.interpolant('LUT','bspline',{xgrid},V);\n"
		"  * LUT(2.5)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Syntax 2D\n"
		"\n"
		"::\n"
		"\n"
		"  * # Python\n"
		"  * xgrid = np.linspace(-5,5,11)\n"
		"  * ygrid = np.linspace(-4,4,9)\n"
		"  * X,Y = np.meshgrid(xgrid,ygrid,indexing='ij')\n"
		"  * R = np.sqrt(5*X**2 + Y**2)+ 1\n"
		"  * data = np.sin(R)/R\n"
		"  * data_flat = data.ravel(order='F')\n"
		"  * LUT = casadi.interpolant('name','bspline',[xgrid,ygrid],data_flat)\n"
		"  * print(LUT([0.5,1]))\n"
		"  * \\\\enverbatim\n"
		"  * \\\\verbatim\n"
		"  * % Matlab\n"
		"  * xgrid = -5:1:5;\n"
		"  * ygrid = -4:1:4;\n"
		"  * R = sqrt(5*X.^2 + Y.^2)+ 1;\n"
		"  * V = sin(R)./(R);\n"
		"  * LUT = interpolant('LUT','bspline',{xgrid, ygrid},V(:));\n"
		"  * LUT([0.5 1])\n"
		"  * \n"
		"\n"
		"General information\n"
		"\n"
		">List of available options\n"
		"\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"|        Id        |      Type       |   Description    |     Used in      |\n"
		"+==================+=================+==================+==================+\n"
		"| ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for derivative   | Internal         |\n"
		"|                  |                 | calculation.When |                  |\n"
		"|                  |                 | there is an      |                  |\n"
		"|                  |                 | option of either |                  |\n"
		"|                  |                 | using forward or |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | directional      |                  |\n"
		"|                  |                 | derivatives, the |                  |\n"
		"|                  |                 | condition ad_wei |                  |\n"
		"|                  |                 | ght*nf<=(1-      |                  |\n"
		"|                  |                 | ad_weight)*na is |                  |\n"
		"|                  |                 | used where nf    |                  |\n"
		"|                  |                 | and na are       |                  |\n"
		"|                  |                 | estimates of the |                  |\n"
		"|                  |                 | number of        |                  |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | mode directional |                  |\n"
		"|                  |                 | derivatives      |                  |\n"
		"|                  |                 | needed. By       |                  |\n"
		"|                  |                 | default,         |                  |\n"
		"|                  |                 | ad_weight is     |                  |\n"
		"|                  |                 | calculated       |                  |\n"
		"|                  |                 | automatically,   |                  |\n"
		"|                  |                 | but this can be  |                  |\n"
		"|                  |                 | overridden by    |                  |\n"
		"|                  |                 | setting this     |                  |\n"
		"|                  |                 | option. In       |                  |\n"
		"|                  |                 | particular, 0    |                  |\n"
		"|                  |                 | means forcing    |                  |\n"
		"|                  |                 | forward mode and |                  |\n"
		"|                  |                 | 1 forcing        |                  |\n"
		"|                  |                 | reverse mode.    |                  |\n"
		"|                  |                 | Leave unset for  |                  |\n"
		"|                  |                 | (class specific) |                  |\n"
		"|                  |                 | heuristics.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |\n"
		"|                  |                 | for sparsity     | Internal         |\n"
		"|                  |                 | pattern          |                  |\n"
		"|                  |                 | calculation calc |                  |\n"
		"|                  |                 | ulation.Override |                  |\n"
		"|                  |                 | s default        |                  |\n"
		"|                  |                 | behavior. Set to |                  |\n"
		"|                  |                 | 0 and 1 to force |                  |\n"
		"|                  |                 | forward and      |                  |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | respectively.    |                  |\n"
		"|                  |                 | Cf. option       |                  |\n"
		"|                  |                 | \"ad_weight\".     |                  |\n"
		"|                  |                 | When set to -1,  |                  |\n"
		"|                  |                 | sparsity is      |                  |\n"
		"|                  |                 | completely       |                  |\n"
		"|                  |                 | ignored and      |                  |\n"
		"|                  |                 | dense matrices   |                  |\n"
		"|                  |                 | are used.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| batch_x          | OT_INT          | Evaluate a batch | casadi::Interpol |\n"
		"|                  |                 | of different     | ant              |\n"
		"|                  |                 | inputs at once   |                  |\n"
		"|                  |                 | (default 1).     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| cache            | OT_DICT         | Prepopulate the  | casadi::Function |\n"
		"|                  |                 | function cache.  | Internal         |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| compiler         | OT_STRING       | Just-in-time     | casadi::Function |\n"
		"|                  |                 | compiler plugin  | Internal         |\n"
		"|                  |                 | to be used.      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |\n"
		"|                  |                 | CasADi's AD. Use | Internal         |\n"
		"|                  |                 | together with    |                  |\n"
		"|                  |                 | 'jac_penalty':   |                  |\n"
		"|                  |                 | 0. Note: Highly  |                  |\n"
		"|                  |                 | experimental.    |                  |\n"
		"|                  |                 | Syntax may break |                  |\n"
		"|                  |                 | often.           |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| der_options      | OT_DICT         | Default options  | casadi::Function |\n"
		"|                  |                 | to be used to    | Internal         |\n"
		"|                  |                 | populate         |                  |\n"
		"|                  |                 | forward_options, |                  |\n"
		"|                  |                 | reverse_options, |                  |\n"
		"|                  |                 | and              |                  |\n"
		"|                  |                 | jacobian_options |                  |\n"
		"|                  |                 | before those     |                  |\n"
		"|                  |                 | options are      |                  |\n"
		"|                  |                 | merged in.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |\n"
		"|                  |                 | a derivative of  | Internal         |\n"
		"|                  |                 | another          |                  |\n"
		"|                  |                 | function. The    |                  |\n"
		"|                  |                 | type of          |                  |\n"
		"|                  |                 | derivative       |                  |\n"
		"|                  |                 | (directional     |                  |\n"
		"|                  |                 | derivative,      |                  |\n"
		"|                  |                 | Jacobian) is     |                  |\n"
		"|                  |                 | inferred from    |                  |\n"
		"|                  |                 | the function     |                  |\n"
		"|                  |                 | name.            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump             | OT_BOOL         | Dump function to | casadi::Function |\n"
		"|                  |                 | file upon first  | Internal         |\n"
		"|                  |                 | evaluation.      |                  |\n"
		"|                  |                 | [false]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_dir         | OT_STRING       | Directory to     | casadi::Function |\n"
		"|                  |                 | dump             | Internal         |\n"
		"|                  |                 | inputs/outputs   |                  |\n"
		"|                  |                 | to. Make sure    |                  |\n"
		"|                  |                 | the directory    |                  |\n"
		"|                  |                 | exists [.]       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_format      | OT_STRING       | Choose file      | casadi::Function |\n"
		"|                  |                 | format to dump   | Internal         |\n"
		"|                  |                 | matrices. See    |                  |\n"
		"|                  |                 | DM.from_file     |                  |\n"
		"|                  |                 | [mtx]            |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | to file          |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs to file  |                  |\n"
		"|                  |                 | (readable with   |                  |\n"
		"|                  |                 | DM.from_file )   |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_fd        | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation by   |                  |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | differencing.    |                  |\n"
		"|                  |                 | [default:        |                  |\n"
		"|                  |                 | false]]          |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_forward   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using forward    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | Jacobians of all |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | outputs with     |                  |\n"
		"|                  |                 | respect to all   |                  |\n"
		"|                  |                 | differentiable   |                  |\n"
		"|                  |                 | inputs - if      |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| enable_reverse   | OT_BOOL         | Enable           | casadi::Function |\n"
		"|                  |                 | derivative       | Internal         |\n"
		"|                  |                 | calculation      |                  |\n"
		"|                  |                 | using generated  |                  |\n"
		"|                  |                 | functions for    |                  |\n"
		"|                  |                 | transposed       |                  |\n"
		"|                  |                 | Jacobian-times-  |                  |\n"
		"|                  |                 | vector products  |                  |\n"
		"|                  |                 | - typically      |                  |\n"
		"|                  |                 | using reverse    |                  |\n"
		"|                  |                 | mode AD - if     |                  |\n"
		"|                  |                 | available.       |                  |\n"
		"|                  |                 | [default: true]  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| error_on_fail    | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when function    | ction            |\n"
		"|                  |                 | evaluation fails |                  |\n"
		"|                  |                 | (default true).  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| external_transfo | OT_VECTORVECTOR | List of external | casadi::Function |\n"
		"| rm               |                 | _transform       | Internal         |\n"
		"|                  |                 | instruction      |                  |\n"
		"|                  |                 | arguments.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_method        | OT_STRING       | Method for       | casadi::Function |\n"
		"|                  |                 | finite           | Internal         |\n"
		"|                  |                 | differencing     |                  |\n"
		"|                  |                 | [default         |                  |\n"
		"|                  |                 | 'central']       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| fd_options       | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | finite           |                  |\n"
		"|                  |                 | difference       |                  |\n"
		"|                  |                 | instance         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| forward_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | forward mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |\n"
		"|                  |                 | option           | Internal         |\n"
		"|                  |                 | (ignored):       |                  |\n"
		"|                  |                 | Statistics are   |                  |\n"
		"|                  |                 | now always       |                  |\n"
		"|                  |                 | collected.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inline           | OT_BOOL         | Implement the    | casadi::Interpol |\n"
		"|                  |                 | lookup table in  | ant              |\n"
		"|                  |                 | MX primitives.   |                  |\n"
		"|                  |                 | Useful when you  |                  |\n"
		"|                  |                 | need derivatives |                  |\n"
		"|                  |                 | with respect to  |                  |\n"
		"|                  |                 | grid and/or      |                  |\n"
		"|                  |                 | coefficients.    |                  |\n"
		"|                  |                 | Such derivatives |                  |\n"
		"|                  |                 | are              |                  |\n"
		"|                  |                 | fundamentally    |                  |\n"
		"|                  |                 | dense, so use    |                  |\n"
		"|                  |                 | with caution.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |\n"
		"|                  |                 | when the         | Internal         |\n"
		"|                  |                 | numerical values |                  |\n"
		"|                  |                 | of the inputs    |                  |\n"
		"|                  |                 | don't make sense |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each input if it | Internal         |\n"
		"|                  |                 | should be        |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |\n"
		"|                  |                 | each output if   | Internal         |\n"
		"|                  |                 | it should be     |                  |\n"
		"|                  |                 | differentiable.  |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |\n"
		"|                  |                 | for a number of  | Internal         |\n"
		"|                  |                 | forward/reverse  |                  |\n"
		"|                  |                 | directions, it   |                  |\n"
		"|                  |                 | may be cheaper   |                  |\n"
		"|                  |                 | to compute first |                  |\n"
		"|                  |                 | the full         |                  |\n"
		"|                  |                 | jacobian and     |                  |\n"
		"|                  |                 | then multiply    |                  |\n"
		"|                  |                 | with seeds,      |                  |\n"
		"|                  |                 | rather than      |                  |\n"
		"|                  |                 | obtain the       |                  |\n"
		"|                  |                 | requested        |                  |\n"
		"|                  |                 | directions in a  |                  |\n"
		"|                  |                 | straightforward  |                  |\n"
		"|                  |                 | manner. Casadi   |                  |\n"
		"|                  |                 | uses a heuristic |                  |\n"
		"|                  |                 | to decide which  |                  |\n"
		"|                  |                 | is cheaper. A    |                  |\n"
		"|                  |                 | high value of    |                  |\n"
		"|                  |                 | 'jac_penalty'    |                  |\n"
		"|                  |                 | makes it less    |                  |\n"
		"|                  |                 | likely for the   |                  |\n"
		"|                  |                 | heurstic to      |                  |\n"
		"|                  |                 | chose the full   |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy. The    |                  |\n"
		"|                  |                 | special value -1 |                  |\n"
		"|                  |                 | indicates never  |                  |\n"
		"|                  |                 | to use the full  |                  |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | strategy         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jacobian_options | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | Jacobian         |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit              | OT_BOOL         | Use just-in-time | casadi::Function |\n"
		"|                  |                 | compiler to      | Internal         |\n"
		"|                  |                 | speed up the     |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |\n"
		"|                  |                 | temporary source | Internal         |\n"
		"|                  |                 | file that jit    |                  |\n"
		"|                  |                 | creates.         |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_name         | OT_STRING       | The file name    | casadi::Function |\n"
		"|                  |                 | used to write    | Internal         |\n"
		"|                  |                 | out code. The    |                  |\n"
		"|                  |                 | actual file      |                  |\n"
		"|                  |                 | names used       |                  |\n"
		"|                  |                 | depend on 'jit_t |                  |\n"
		"|                  |                 | emp_suffix' and  |                  |\n"
		"|                  |                 | include          |                  |\n"
		"|                  |                 | extensions.      |                  |\n"
		"|                  |                 | Default:         |                  |\n"
		"|                  |                 | 'jit_tmp'        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_options      | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to the    | Internal         |\n"
		"|                  |                 | jit compiler.    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_serialize    | OT_STRING       | Specify          | casadi::Function |\n"
		"|                  |                 | behaviour when   | Internal         |\n"
		"|                  |                 | serializing a    |                  |\n"
		"|                  |                 | jitted function: |                  |\n"
		"|                  |                 | SOURCE|link|embe |                  |\n"
		"|                  |                 | d.               |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |\n"
		"|                  |                 | (seemingly       | Internal         |\n"
		"|                  |                 | random) filename |                  |\n"
		"|                  |                 | suffix for       |                  |\n"
		"|                  |                 | generated code   |                  |\n"
		"|                  |                 | and libraries.   |                  |\n"
		"|                  |                 | This is desired  |                  |\n"
		"|                  |                 | for thread-      |                  |\n"
		"|                  |                 | safety. This     |                  |\n"
		"|                  |                 | behaviour may    |                  |\n"
		"|                  |                 | defeat caching   |                  |\n"
		"|                  |                 | compiler         |                  |\n"
		"|                  |                 | wrappers.        |                  |\n"
		"|                  |                 | Default: true    |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| lookup_mode      | OT_STRINGVECTOR | Specifies, for   | casadi::Interpol |\n"
		"|                  |                 | each grid        | ant              |\n"
		"|                  |                 | dimension, the   |                  |\n"
		"|                  |                 | lookup algorithm |                  |\n"
		"|                  |                 | used to find the |                  |\n"
		"|                  |                 | correct index.   |                  |\n"
		"|                  |                 | 'linear' uses a  |                  |\n"
		"|                  |                 | for-loop +       |                  |\n"
		"|                  |                 | break; (default  |                  |\n"
		"|                  |                 | when             |                  |\n"
		"|                  |                 | #knots<=100),    |                  |\n"
		"|                  |                 | 'exact' uses     |                  |\n"
		"|                  |                 | floored division |                  |\n"
		"|                  |                 | (only for        |                  |\n"
		"|                  |                 | uniform grids),  |                  |\n"
		"|                  |                 | 'binary' uses a  |                  |\n"
		"|                  |                 | binary search.   |                  |\n"
		"|                  |                 | (default when    |                  |\n"
		"|                  |                 | #knots>100).     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_io           | OT_INT          | Acceptable       | casadi::Function |\n"
		"|                  |                 | number of inputs | Internal         |\n"
		"|                  |                 | and outputs.     |                  |\n"
		"|                  |                 | Warn if          |                  |\n"
		"|                  |                 | exceeded.        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| max_num_dir      | OT_INT          | Specify the      | casadi::Function |\n"
		"|                  |                 | maximum number   | Internal         |\n"
		"|                  |                 | of directions    |                  |\n"
		"|                  |                 | for derivative   |                  |\n"
		"|                  |                 | functions.       |                  |\n"
		"|                  |                 | Overrules the    |                  |\n"
		"|                  |                 | builtin optimize |                  |\n"
		"|                  |                 | d_num_dir.       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |\n"
		"|                  |                 |                  | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |\n"
		"|                  |                 | option (ignored) | Internal         |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand      | OT_BOOL         | After            | casadi::Function |\n"
		"|                  |                 | construction,    | Internal         |\n"
		"|                  |                 | expand this      |                  |\n"
		"|                  |                 | Function .       |                  |\n"
		"|                  |                 | Default: False   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| post_expand_opti | OT_DICT         | Options to be    | casadi::Function |\n"
		"| ons              |                 | passed to post-  | Internal         |\n"
		"|                  |                 | construction     |                  |\n"
		"|                  |                 | expansion.       |                  |\n"
		"|                  |                 | Default: empty   |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_in         | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of inputs | Internal         |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_out        | OT_BOOL         | Print numerical  | casadi::Function |\n"
		"|                  |                 | values of        | Internal         |\n"
		"|                  |                 | outputs          |                  |\n"
		"|                  |                 | [default: false] |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| print_time       | OT_BOOL         | print            | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time. Implies    |                  |\n"
		"|                  |                 | record_time.     |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| record_time      | OT_BOOL         | record           | casadi::ProtoFun |\n"
		"|                  |                 | information      | ction            |\n"
		"|                  |                 | about execution  |                  |\n"
		"|                  |                 | time, for        |                  |\n"
		"|                  |                 | retrieval with   |                  |\n"
		"|                  |                 | stats().         |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |\n"
		"|                  |                 | when NaN or Inf  | ction            |\n"
		"|                  |                 | appears during   |                  |\n"
		"|                  |                 | evaluation       |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| reverse_options  | OT_DICT         | Options to be    | casadi::Function |\n"
		"|                  |                 | passed to a      | Internal         |\n"
		"|                  |                 | reverse mode     |                  |\n"
		"|                  |                 | constructor      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |\n"
		"|                  |                 | field that can   | Internal         |\n"
		"|                  |                 | be used to       |                  |\n"
		"|                  |                 | identify the     |                  |\n"
		"|                  |                 | function or pass |                  |\n"
		"|                  |                 | additional       |                  |\n"
		"|                  |                 | information      |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"| verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |\n"
		"|                  |                 | evaluation  for  | ction            |\n"
		"|                  |                 | debugging        |                  |\n"
		"+------------------+-----------------+------------------+------------------+\n"
		"\n"
		"List of plugins\n"
		"- bspline\n"
		"\n"
		"- linear\n"
		"\n"
		"Note: some of the plugins in this list might not be available on your \n"
		"\n"
		"system.  Also, there might be extra plugins available to you that are \n"
		"not \n"
		"listed here. You can obtain their documentation with  \n"
		"Interpolant.doc(\"myextraplugin\")\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"bspline\n"
		"-------\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_239\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"|          Id           |     Type     |            Description            |\n"
		"+=======================+==============+===================================+\n"
		"| algorithm             | OT_STRING    | Algorithm used for fitting the    |\n"
		"|                       |              | data: 'not_a_knot' (default, same |\n"
		"|                       |              | as Matlab), 'smooth_linear'.      |\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"| degree                | OT_INTVECTOR | Sets, for each grid dimension,    |\n"
		"|                       |              | the degree of the spline.         |\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"| linear_solver         | OT_STRING    | Solver used for constructing the  |\n"
		"|                       |              | coefficient tensor.               |\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"| linear_solver_options | OT_DICT      | Options to be passed to the       |\n"
		"|                       |              | linear solver.                    |\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"| smooth_linear_frac    | OT_DOUBLE    | When 'smooth_linear' algorithm is |\n"
		"|                       |              | active, determines sharpness      |\n"
		"|                       |              | between 0 (sharp, as linear       |\n"
		"|                       |              | interpolation) and 0.5            |\n"
		"|                       |              | (smooth).Default value is 0.1.    |\n"
		"+-----------------------+--------------+-----------------------------------+\n"
		"\n"
		"\n"
		"\n"
		"--------------------------------------------------------------------------------\n"
		"\n"
		"linear\n"
		"------\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23b\n"
		"\n"
		">List of available options\n"
		"\n"
		"+-------------+-----------------+------------------------------------------+\n"
		"|     Id      |      Type       |               Description                |\n"
		"+=============+=================+==========================================+\n"
		"| lookup_mode | OT_STRINGVECTOR | Sets, for each grid dimenion, the lookup |\n"
		"|             |                 | algorithm used to find the correct       |\n"
		"|             |                 | index. 'linear' uses a for-loop + break; |\n"
		"|             |                 | 'exact' uses floored division (only for  |\n"
		"|             |                 | uniform grids).                          |\n"
		"+-------------+-----------------+------------------------------------------+\n"
		"\n"
		"Joel Andersson\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_21p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L125\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L125-L147\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  interpolant(str name, str solver, [[float]] grid, int m, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Parametric variant of interpolant.\n"
		"\n"
		"The resulting function will have an additional argument for the \n"
		"\n"
		"coefficients\n"
		"\n"
		"By default, derivatives wrt the coefficients are not supported (zero).\n"
		" Some\n"
		" interpolant plugins may support the  inline=true which enables correct \n"
		"derivatives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L189-L203\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  interpolant(str name, str solver, [int] grid_dims, int m, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Parametric variant of interpolant.\n"
		"\n"
		"The resulting function will have additional arguments for the grid and\n"
		"\n"
		"coefficients\n"
		"\n"
		"By default, derivatives wrt the coefficients are not supported (zero).\n"
		" Some\n"
		" interpolant plugins may support the  inline=true which enables correct \n"
		"derivatives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L205\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L205-L213\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  interpolant(str name, str solver, [int] grid_dims, [float] values, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Parametric variant of interpolant.\n"
		"\n"
		"The resulting function will have an additional argument for the grid\n"
		"\n"
		"By default, derivatives wrt the coefficients are not supported (zero).\n"
		" Some\n"
		" interpolant plugins may support the  inline=true which enables correct \n"
		"derivatives\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L171\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L171-L187\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"has_interpolant", (PyCFunction)_wrap_has_interpolant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_interpolant(str name) -> bool\n"
		"\n"
		"Check if a particular plugin is available.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L34\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L34-L36\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"load_interpolant", (PyCFunction)_wrap_load_interpolant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_interpolant(str name)\n"
		"\n"
		"Explicitly load a plugin dynamically.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L38\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L38-L40\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"doc_interpolant", (PyCFunction)_wrap_doc_interpolant, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  doc_interpolant(str name) -> str\n"
		"\n"
		"Get the documentation string for a plugin.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.hpp#L42\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/interpolant.cpp#L42-L44\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_CodeGenerator", _wrap_new_CodeGenerator, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  CodeGenerator(str name, dict opts)\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.hpp#L46\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.cpp#L35-L183\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CodeGenerator_add", _wrap_CodeGenerator_add, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add(self, Function f, bool with_jac_sparsity)\n"
		"\n"
		"Add a function (name generated)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.hpp#L49\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.cpp#L304-L347\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CodeGenerator_dump", (PyCFunction)_wrap_CodeGenerator_dump, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dump(self) -> str\n"
		"\n"
		"Generate a file, return code as string.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.hpp#L57\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.cpp#L349-L353\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CodeGenerator_generate", _wrap_CodeGenerator_generate, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  generate(self, str prefix) -> str\n"
		"\n"
		"Generate file(s)\n"
		"\n"
		"The \"prefix\" argument will be prepended to the generated files and \n"
		"may be\n"
		" a directory or a file prefix. returns the filename\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.hpp#L66\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.cpp#L441-L495\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CodeGenerator_add_include", _wrap_CodeGenerator_add_include, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_include(self, str new_include, bool relative_path, str use_ifdef)\n"
		"\n"
		"Add an include file optionally using a relative path \"...\" \n"
		"instead \n"
		"of an absolute path <...>\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.hpp#L69\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/code_generator.cpp#L986-L1006\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_CodeGenerator", (PyCFunction)_wrap_delete_CodeGenerator, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  CodeGenerator(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CodeGenerator_swigregister", CodeGenerator_swigregister, METH_VARARGS, NULL},
	 { (char *)"_horzcat", _wrap__horzcat, METH_VARARGS, (char *)"\n"
		"  Concatenate horizontally, six matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  _horzcat([Sparsity] v) -> Sparsity\n"
		"  _horzcat([DM] v) -> DM\n"
		"  _horzcat([SX] v) -> SX\n"
		"  _horzcat([MX] v) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_4e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L502\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L502-L505\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"_vertcat", _wrap__vertcat, METH_VARARGS, (char *)"\n"
		"  Concatenate vertically, six matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  _vertcat([Sparsity] v) -> Sparsity\n"
		"  _vertcat([DM] v) -> DM\n"
		"  _vertcat([SX] v) -> SX\n"
		"  _vertcat([MX] v) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_4j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L540\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L540-L543\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"horzsplit", _wrap_horzsplit, METH_VARARGS, (char *)"\n"
		"  split horizontally, retaining fixed-sized groups of columns\n"
		"\n"
		"::\n"
		"\n"
		"  horzsplit(Sparsity v, int incr) -> [Sparsity]\n"
		"  horzsplit(DM v, int incr) -> [DM]\n"
		"  horzsplit(SX v, int incr) -> [SX]\n"
		"  horzsplit(MX v, int incr) -> [MX]\n"
		"  horzsplit(Sparsity v, [int] offset) -> [Sparsity]\n"
		"  horzsplit(DM v, [int] offset) -> [DM]\n"
		"  horzsplit(SX v, [int] offset) -> [SX]\n"
		"  horzsplit(MX v, [int] offset) -> [MX]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"incr: \n"
		"Size (width) of each group of columns\n"
		"\n"
		"horzcat(horzsplit(x, ...)) = x\n"
		"\n"
		"\\\\seealso horzsplit_n\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L134\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L134-L136\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"horzsplit_n", _wrap_horzsplit_n, METH_VARARGS, (char *)"\n"
		"  split horizontally, retaining fixed-sized groups of columns\n"
		"\n"
		"::\n"
		"\n"
		"  horzsplit_n(Sparsity v, int n) -> [Sparsity]\n"
		"  horzsplit_n(DM v, int n) -> [DM]\n"
		"  horzsplit_n(SX v, int n) -> [SX]\n"
		"  horzsplit_n(MX v, int n) -> [MX]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n: \n"
		"Number of groups of columns\n"
		"\n"
		"Will error when the number of columns is not a multiple of n\n"
		"\n"
		"horzcat(horzsplit(x, ...)) = x\n"
		"\n"
		"\\\\seealso horzsplit\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_277\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L149\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L149-L151\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"offset", _wrap_offset, METH_VARARGS, (char *)"\n"
		"  Helper function, get offsets corresponding to a vector of matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  offset([Sparsity] v, bool vert) -> [int]\n"
		"  offset([DM] v, bool vert) -> [int]\n"
		"  offset([SX] v, bool vert) -> [int]\n"
		"  offset([MX] v, bool vert) -> [int]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L169\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L169-L171\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"vertsplit", _wrap_vertsplit, METH_VARARGS, (char *)"\n"
		"  split vertically, retaining fixed-sized groups of rows\n"
		"\n"
		"::\n"
		"\n"
		"  vertsplit(Sparsity v, int incr) -> [Sparsity]\n"
		"  vertsplit(DM v, int incr) -> [DM]\n"
		"  vertsplit(SX v, int incr) -> [SX]\n"
		"  vertsplit(MX v, int incr) -> [MX]\n"
		"  vertsplit(Sparsity v, [int] offset) -> [Sparsity]\n"
		"  vertsplit(DM v, [int] offset) -> [DM]\n"
		"  vertsplit(SX v, [int] offset) -> [SX]\n"
		"  vertsplit(MX v, [int] offset) -> [MX]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"incr: \n"
		"Size of each group of rows\n"
		"\n"
		"vertcat(vertsplit(x, ...)) = x\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  >>> print vertsplit(SX.sym(\"a\",4))\n"
		"  [SX(a_0), SX(a_1), SX(a_2), SX(a_3)]\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  >>> print vertsplit(SX.sym(\"a\",4),2)\n"
		"  [SX([a_0, a_1]), SX([a_2, a_3])]\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"If the number of rows is not a multiple of  incr, the last entry returned \n"
		"will have a size smaller than  incr.\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  >>> print vertsplit(DM([0,1,2,3,4]),2)\n"
		"  [DM([0, 1]), DM([2, 3]), DM(4)]\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"\\\\seealso vertsplit_n\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L204\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L204-L206\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"vertsplit_n", _wrap_vertsplit_n, METH_VARARGS, (char *)"\n"
		"  split vertically, retaining fixed-sized groups of rows\n"
		"\n"
		"::\n"
		"\n"
		"  vertsplit_n(Sparsity v, int n) -> [Sparsity]\n"
		"  vertsplit_n(DM v, int n) -> [DM]\n"
		"  vertsplit_n(SX v, int n) -> [SX]\n"
		"  vertsplit_n(MX v, int n) -> [MX]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n: \n"
		"Number of groups of rows\n"
		"\n"
		"Will error when the number of rows is not a multiple of n\n"
		"\n"
		"vertcat(vertsplit(x, ...)) = x\n"
		"\n"
		"\\\\seealso vertsplit\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_278\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L219\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L219-L221\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"blocksplit", _wrap_blocksplit, METH_VARARGS, (char *)"\n"
		"  chop up into blocks\n"
		"\n"
		"::\n"
		"\n"
		"  blocksplit(Sparsity x, int vert_incr, int horz_incr) -> [[Sparsity]]\n"
		"  blocksplit(DM x, int vert_incr, int horz_incr) -> [[DM]]\n"
		"  blocksplit(SX x, int vert_incr, int horz_incr) -> [[SX]]\n"
		"  blocksplit(MX x, int vert_incr, int horz_incr) -> [[MX]]\n"
		"  blocksplit(Sparsity x, [int] vert_offset, [int] horz_offset) -> [[Sparsity]]\n"
		"  blocksplit(DM x, [int] vert_offset, [int] horz_offset) -> [[DM]]\n"
		"  blocksplit(SX x, [int] vert_offset, [int] horz_offset) -> [[SX]]\n"
		"  blocksplit(MX x, [int] vert_offset, [int] horz_offset) -> [[MX]]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"vert_incr: \n"
		"Defines the increment for block boundaries in row dimension\n"
		"\n"
		"horz_incr: \n"
		"Defines the increment for block boundaries in column dimension\n"
		"\n"
		"blockcat(blocksplit(x,..., ...)) = x\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L262\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L262-L264\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"_diagcat", _wrap__diagcat, METH_VARARGS, (char *)"\n"
		"  Concatenate along diagonal, six matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  _diagcat([Sparsity] A) -> Sparsity\n"
		"  _diagcat([DM] A) -> DM\n"
		"  _diagcat([SX] A) -> SX\n"
		"  _diagcat([MX] A) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_4o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L578\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L578-L581\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"diagsplit", _wrap_diagsplit, METH_VARARGS, (char *)"\n"
		"  split diagonally, retaining fixed-sized matrices\n"
		"\n"
		"::\n"
		"\n"
		"  diagsplit(Sparsity x, int incr) -> [Sparsity]\n"
		"  diagsplit(DM x, int incr) -> [DM]\n"
		"  diagsplit(SX x, int incr) -> [SX]\n"
		"  diagsplit(MX x, int incr) -> [MX]\n"
		"  diagsplit(Sparsity x, [int] output_offset) -> [Sparsity]\n"
		"  diagsplit(DM x, [int] output_offset) -> [DM]\n"
		"  diagsplit(SX x, [int] output_offset) -> [SX]\n"
		"  diagsplit(MX x, [int] output_offset) -> [MX]\n"
		"  diagsplit(Sparsity x, int incr1, int incr2) -> [Sparsity]\n"
		"  diagsplit(Sparsity x, [int] output_offset1, [int] output_offset2) -> [Sparsity]\n"
		"  diagsplit(DM x, int incr1, int incr2) -> [DM]\n"
		"  diagsplit(DM x, [int] output_offset1, [int] output_offset2) -> [DM]\n"
		"  diagsplit(SX x, int incr1, int incr2) -> [SX]\n"
		"  diagsplit(SX x, [int] output_offset1, [int] output_offset2) -> [SX]\n"
		"  diagsplit(MX x, int incr1, int incr2) -> [MX]\n"
		"  diagsplit(MX x, [int] output_offset1, [int] output_offset2) -> [MX]\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"incr1: \n"
		"Row dimension of each matrix\n"
		"\n"
		"incr2: \n"
		"Column dimension of each matrix\n"
		"\n"
		"diagsplit(diagsplit(x, ...)) = x\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L324\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L324-L326\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"_veccat", _wrap__veccat, METH_VARARGS, (char *)"\n"
		"  concatenate vertically while vectorizing all arguments with vec\n"
		"\n"
		"::\n"
		"\n"
		"  _veccat([Sparsity] x) -> Sparsity\n"
		"  _veccat([DM] x) -> DM\n"
		"  _veccat([SX] x) -> SX\n"
		"  _veccat([MX] x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L331\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L331-L333\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mtimes", _wrap_mtimes, METH_VARARGS, (char *)"\n"
		"  Matrix product of n matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  mtimes([Sparsity] args) -> Sparsity\n"
		"  mtimes([DM] args) -> DM\n"
		"  mtimes([SX] args) -> SX\n"
		"  mtimes([MX] args) -> MX\n"
		"  mtimes(Sparsity x, Sparsity y) -> Sparsity\n"
		"  mtimes(DM x, DM y) -> DM\n"
		"  mtimes(SX x, SX y) -> SX\n"
		"  mtimes(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L345\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L345-L347\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mac", _wrap_mac, METH_VARARGS, (char *)"\n"
		"  Multiply-accumulate operation.\n"
		"\n"
		"::\n"
		"\n"
		"  mac(Sparsity X, Sparsity Y, Sparsity Z) -> Sparsity\n"
		"  mac(DM X, DM Y, DM Z) -> DM\n"
		"  mac(SX X, SX Y, SX Z) -> SX\n"
		"  mac(MX X, MX Y, MX Z) -> MX\n"
		"\n"
		"\n"
		"Matrix product of two matrices (x and y), adding the result to a third \n"
		"\n"
		"matrix z. The result has the same sparsity pattern as C meaning that \n"
		"other \n"
		"entries of (x*y) are ignored. The operation is equivalent to: \n"
		"\n"
		"z+mtimes(x,y).project(z.sparsity()).\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L358\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L358-L360\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"transpose", _wrap_transpose, METH_VARARGS, (char *)"\n"
		"  Transpose.\n"
		"\n"
		"::\n"
		"\n"
		"  transpose(Sparsity X) -> Sparsity\n"
		"  transpose(DM X) -> DM\n"
		"  transpose(SX X) -> SX\n"
		"  transpose(MX X) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L365\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L365-L367\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"vec", _wrap_vec, METH_VARARGS, (char *)"\n"
		"  make a vector\n"
		"\n"
		"::\n"
		"\n"
		"  vec(Sparsity a) -> Sparsity\n"
		"  vec(DM a) -> DM\n"
		"  vec(SX a) -> SX\n"
		"  vec(MX a) -> MX\n"
		"\n"
		"\n"
		"Reshapes/vectorizes the matrix such that the shape becomes \n"
		"(expr.numel(), \n"
		"1). Columns are stacked on top of each other. Same as \n"
		"reshape(expr, \n"
		"expr.numel(), 1)\n"
		"\n"
		"a c \n"
		"b d \n"
		" turns into\n"
		"\n"
		"a \n"
		"b \n"
		"c \n"
		"d \n"
		" Extra doc: https://github.com/casadi/casadi/wiki/L_3z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L386\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L386-L388\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"reshape", _wrap_reshape, METH_VARARGS, (char *)"\n"
		"  Reshape the matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  reshape(Sparsity a, (int,int) rc) -> Sparsity\n"
		"  reshape(Sparsity a, Sparsity sp) -> Sparsity\n"
		"  reshape(DM a, (int,int) rc) -> DM\n"
		"  reshape(DM a, Sparsity sp) -> DM\n"
		"  reshape(SX a, (int,int) rc) -> SX\n"
		"  reshape(SX a, Sparsity sp) -> SX\n"
		"  reshape(MX a, (int,int) rc) -> MX\n"
		"  reshape(MX a, Sparsity sp) -> MX\n"
		"  reshape(Sparsity a, int nrow, int ncol) -> Sparsity\n"
		"  reshape(DM a, int nrow, int ncol) -> DM\n"
		"  reshape(SX a, int nrow, int ncol) -> SX\n"
		"  reshape(MX a, int nrow, int ncol) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_42\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L407\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L407-L409\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sparsity_cast", _wrap_sparsity_cast, METH_VARARGS, (char *)"\n"
		"  Cast matrix nonzeros to different Sparsity.\n"
		"\n"
		"::\n"
		"\n"
		"  sparsity_cast(Sparsity a, Sparsity sp) -> Sparsity\n"
		"  sparsity_cast(DM a, Sparsity sp) -> DM\n"
		"  sparsity_cast(SX a, Sparsity sp) -> SX\n"
		"  sparsity_cast(MX a, Sparsity sp) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_24z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L414\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L414-L416\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sprank", _wrap_sprank, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  sprank(Sparsity A) -> int\n"
		"  sprank(DM A) -> int\n"
		"  sprank(SX A) -> int\n"
		"  sprank(MX A) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_0_mul", _wrap_norm_0_mul, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  norm_0_mul(Sparsity x, Sparsity y) -> int\n"
		"  norm_0_mul(DM x, DM y) -> int\n"
		"  norm_0_mul(SX x, SX y) -> int\n"
		"  norm_0_mul(MX x, MX y) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"triu", _wrap_triu, METH_VARARGS, (char *)"\n"
		"  Get the upper triangular part of a matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  triu(Sparsity a, bool includeDiagonal) -> Sparsity\n"
		"  triu(DM a, bool includeDiagonal) -> DM\n"
		"  triu(SX a, bool includeDiagonal) -> SX\n"
		"  triu(MX a, bool includeDiagonal) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_45\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L435\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L435-L437\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"tril", _wrap_tril, METH_VARARGS, (char *)"\n"
		"  Get the lower triangular part of a matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  tril(Sparsity a, bool includeDiagonal) -> Sparsity\n"
		"  tril(DM a, bool includeDiagonal) -> DM\n"
		"  tril(SX a, bool includeDiagonal) -> SX\n"
		"  tril(MX a, bool includeDiagonal) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_46\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L442\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L442-L444\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"kron", _wrap_kron, METH_VARARGS, (char *)"\n"
		"  Kronecker tensor product.\n"
		"\n"
		"::\n"
		"\n"
		"  kron(Sparsity a, Sparsity b) -> Sparsity\n"
		"  kron(DM a, DM b) -> DM\n"
		"  kron(SX a, SX b) -> SX\n"
		"  kron(MX a, MX b) -> MX\n"
		"\n"
		"\n"
		"Creates a block matrix in which each element (i, j) is a_ij*b\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_47\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L451\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L451-L453\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"repmat", _wrap_repmat, METH_VARARGS, (char *)"\n"
		"  Repeat matrix A n times vertically and m times horizontally.\n"
		"\n"
		"::\n"
		"\n"
		"  repmat(Sparsity A, int n, int m) -> Sparsity\n"
		"  repmat(Sparsity A, (int,int) rc) -> Sparsity\n"
		"  repmat(DM A, int n, int m) -> DM\n"
		"  repmat(DM A, (int,int) rc) -> DM\n"
		"  repmat(SX A, int n, int m) -> SX\n"
		"  repmat(SX A, (int,int) rc) -> SX\n"
		"  repmat(MX A, int n, int m) -> MX\n"
		"  repmat(MX A, (int,int) rc) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_49\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L465\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L465-L467\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sum2", _wrap_sum2, METH_VARARGS, (char *)"\n"
		"  Return a column-wise summation of elements.\n"
		"\n"
		"::\n"
		"\n"
		"  sum2(Sparsity x) -> Sparsity\n"
		"  sum2(DM x) -> DM\n"
		"  sum2(SX x) -> SX\n"
		"  sum2(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_4q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L591\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L591-L591\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sum1", _wrap_sum1, METH_VARARGS, (char *)"\n"
		"  Return a row-wise summation of elements.\n"
		"\n"
		"::\n"
		"\n"
		"  sum1(Sparsity x) -> Sparsity\n"
		"  sum1(DM x) -> DM\n"
		"  sum1(SX x) -> SX\n"
		"  sum1(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_4p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L586\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L586-L586\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"plus", _wrap_plus, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  plus(float x, float y) -> float\n"
		"  plus(DM x, DM y) -> DM\n"
		"  plus(SX x, SX y) -> SX\n"
		"  plus(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"minus", _wrap_minus, METH_VARARGS, (char *)"\n"
		"  Subtraction: (x,y) -> x - y.\n"
		"\n"
		"::\n"
		"\n"
		"  minus(float x, float y) -> float\n"
		"  minus(DM x, DM y) -> DM\n"
		"  minus(SX x, SX y) -> SX\n"
		"  minus(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oo\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L83\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L83-L85\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"times", _wrap_times, METH_VARARGS, (char *)"\n"
		"  Elementwise multiplication: (x,y) -> x .* y.\n"
		"\n"
		"::\n"
		"\n"
		"  times(float x, float y) -> float\n"
		"  times(DM x, DM y) -> DM\n"
		"  times(SX x, SX y) -> SX\n"
		"  times(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_op\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L99-L101\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rdivide", _wrap_rdivide, METH_VARARGS, (char *)"\n"
		"  Elementwise division: (x,y) -> x ./ y.\n"
		"\n"
		"::\n"
		"\n"
		"  rdivide(float x, float y) -> float\n"
		"  rdivide(DM x, DM y) -> DM\n"
		"  rdivide(SX x, SX y) -> SX\n"
		"  rdivide(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L115\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L115-L117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ldivide", _wrap_ldivide, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  ldivide(float x, float y) -> float\n"
		"  ldivide(DM x, DM y) -> DM\n"
		"  ldivide(SX x, SX y) -> SX\n"
		"  ldivide(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"lt", _wrap_lt, METH_VARARGS, (char *)"\n"
		"  Logical less than: (x,y) -> x < y.\n"
		"\n"
		"::\n"
		"\n"
		"  lt(float x, float y) -> float\n"
		"  lt(DM x, DM y) -> DM\n"
		"  lt(SX x, SX y) -> SX\n"
		"  lt(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_or\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L131\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L131-L133\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"le", _wrap_le, METH_VARARGS, (char *)"\n"
		"  Logical less or equal to: (x,y) -> x <= y.\n"
		"\n"
		"::\n"
		"\n"
		"  le(float x, float y) -> float\n"
		"  le(DM x, DM y) -> DM\n"
		"  le(SX x, SX y) -> SX\n"
		"  le(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_os\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L146\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L146-L148\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"gt", _wrap_gt, METH_VARARGS, (char *)"\n"
		"  Logical greater than: (x,y) -> x > y.\n"
		"\n"
		"::\n"
		"\n"
		"  gt(float x, float y) -> float\n"
		"  gt(DM x, DM y) -> DM\n"
		"  gt(SX x, SX y) -> SX\n"
		"  gt(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ot\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L161\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L161-L163\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ge", _wrap_ge, METH_VARARGS, (char *)"\n"
		"  Logical greater or equal to: (x,y) -> x >= y.\n"
		"\n"
		"::\n"
		"\n"
		"  ge(float x, float y) -> float\n"
		"  ge(DM x, DM y) -> DM\n"
		"  ge(SX x, SX y) -> SX\n"
		"  ge(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ou\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L176\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L176-L178\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"eq", _wrap_eq, METH_VARARGS, (char *)"\n"
		"  Logical equal to: (x,y) -> x == y.\n"
		"\n"
		"::\n"
		"\n"
		"  eq(float x, float y) -> float\n"
		"  eq(DM x, DM y) -> DM\n"
		"  eq(SX x, SX y) -> SX\n"
		"  eq(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ov\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L191\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L191-L193\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ne", _wrap_ne, METH_VARARGS, (char *)"\n"
		"  Logical not equal to: (x,y) -> x != y.\n"
		"\n"
		"::\n"
		"\n"
		"  ne(float x, float y) -> float\n"
		"  ne(DM x, DM y) -> DM\n"
		"  ne(SX x, SX y) -> SX\n"
		"  ne(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ow\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L206\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L206-L208\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logic_and", _wrap_logic_and, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  logic_and(float x, float y) -> float\n"
		"  logic_and(DM x, DM y) -> DM\n"
		"  logic_and(SX x, SX y) -> SX\n"
		"  logic_and(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logic_or", _wrap_logic_or, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  logic_or(float x, float y) -> float\n"
		"  logic_or(DM x, DM y) -> DM\n"
		"  logic_or(SX x, SX y) -> SX\n"
		"  logic_or(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logic_not", _wrap_logic_not, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  logic_not(float x) -> float\n"
		"  logic_not(DM x) -> DM\n"
		"  logic_not(SX x) -> SX\n"
		"  logic_not(MX x) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"fabs", _wrap_fabs, METH_VARARGS, (char *)"\n"
		"  Absolute value: x -> abs(x)\n"
		"\n"
		"::\n"
		"\n"
		"  fabs(float x) -> float\n"
		"  fabs(DM x) -> DM\n"
		"  fabs(SX x) -> SX\n"
		"  fabs(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L275\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L275-L277\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sqrt", _wrap_sqrt, METH_VARARGS, (char *)"\n"
		"  Square root: x -> sqrt(x)\n"
		"\n"
		"::\n"
		"\n"
		"  sqrt(float x) -> float\n"
		"  sqrt(DM x) -> DM\n"
		"  sqrt(SX x) -> SX\n"
		"  sqrt(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L290\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L290-L292\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sin", _wrap_sin, METH_VARARGS, (char *)"\n"
		"  Sine: x -> sin(x)\n"
		"\n"
		"::\n"
		"\n"
		"  sin(float x) -> float\n"
		"  sin(DM x) -> DM\n"
		"  sin(SX x) -> SX\n"
		"  sin(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L314\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L314-L316\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cos", _wrap_cos, METH_VARARGS, (char *)"\n"
		"  Cosine: x -> cos(x)\n"
		"\n"
		"::\n"
		"\n"
		"  cos(float x) -> float\n"
		"  cos(DM x) -> DM\n"
		"  cos(SX x) -> SX\n"
		"  cos(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L326\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L326-L328\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"tan", _wrap_tan, METH_VARARGS, (char *)"\n"
		"  Tangent: x -> tan(x)\n"
		"\n"
		"::\n"
		"\n"
		"  tan(float x) -> float\n"
		"  tan(DM x) -> DM\n"
		"  tan(SX x) -> SX\n"
		"  tan(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L338\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L338-L340\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"atan", _wrap_atan, METH_VARARGS, (char *)"\n"
		"  Arc tangent: x -> atan(x)\n"
		"\n"
		"::\n"
		"\n"
		"  atan(float x) -> float\n"
		"  atan(DM x) -> DM\n"
		"  atan(SX x) -> SX\n"
		"  atan(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L350\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L350-L352\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"asin", _wrap_asin, METH_VARARGS, (char *)"\n"
		"  Arc sine: x -> asin(x)\n"
		"\n"
		"::\n"
		"\n"
		"  asin(float x) -> float\n"
		"  asin(DM x) -> DM\n"
		"  asin(SX x) -> SX\n"
		"  asin(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L362\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L362-L364\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"acos", _wrap_acos, METH_VARARGS, (char *)"\n"
		"  Arc cosine: x -> acos(x)\n"
		"\n"
		"::\n"
		"\n"
		"  acos(float x) -> float\n"
		"  acos(DM x) -> DM\n"
		"  acos(SX x) -> SX\n"
		"  acos(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L374\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L374-L376\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"tanh", _wrap_tanh, METH_VARARGS, (char *)"\n"
		"  Hyperbolic tangent: x -> tanh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  tanh(float x) -> float\n"
		"  tanh(DM x) -> DM\n"
		"  tanh(SX x) -> SX\n"
		"  tanh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_p9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L386\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L386-L388\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sinh", _wrap_sinh, METH_VARARGS, (char *)"\n"
		"  Hyperbolic sin: x -> sinh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  sinh(float x) -> float\n"
		"  sinh(DM x) -> DM\n"
		"  sinh(SX x) -> SX\n"
		"  sinh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pa\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L398\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L398-L400\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cosh", _wrap_cosh, METH_VARARGS, (char *)"\n"
		"  Hyperbolic cosine: x -> cosh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  cosh(float x) -> float\n"
		"  cosh(DM x) -> DM\n"
		"  cosh(SX x) -> SX\n"
		"  cosh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L410\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L410-L412\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"atanh", _wrap_atanh, METH_VARARGS, (char *)"\n"
		"  Inverse hyperbolic tangent: x -> atanh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  atanh(float x) -> float\n"
		"  atanh(DM x) -> DM\n"
		"  atanh(SX x) -> SX\n"
		"  atanh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L422\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L422-L424\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"asinh", _wrap_asinh, METH_VARARGS, (char *)"\n"
		"  Inverse hyperbolic sin: x -> asinh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  asinh(float x) -> float\n"
		"  asinh(DM x) -> DM\n"
		"  asinh(SX x) -> SX\n"
		"  asinh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L434\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L434-L436\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"acosh", _wrap_acosh, METH_VARARGS, (char *)"\n"
		"  Inverse hyperbolic cosine: x -> acosh(x)\n"
		"\n"
		"::\n"
		"\n"
		"  acosh(float x) -> float\n"
		"  acosh(DM x) -> DM\n"
		"  acosh(SX x) -> SX\n"
		"  acosh(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pe\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L446\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L446-L448\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"exp", _wrap_exp, METH_VARARGS, (char *)"\n"
		"  Elementwise exponential: x -> exp(x)\n"
		"\n"
		"::\n"
		"\n"
		"  exp(float x) -> float\n"
		"  exp(DM x) -> DM\n"
		"  exp(SX x) -> SX\n"
		"  exp(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L458\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L458-L460\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"log", _wrap_log, METH_VARARGS, (char *)"\n"
		"  Natural logarithm: x -> log(x)\n"
		"\n"
		"::\n"
		"\n"
		"  log(float x) -> float\n"
		"  log(DM x) -> DM\n"
		"  log(SX x) -> SX\n"
		"  log(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L470\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L470-L472\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"log10", _wrap_log10, METH_VARARGS, (char *)"\n"
		"  Base-10 logarithm: x -> log10(x)\n"
		"\n"
		"::\n"
		"\n"
		"  log10(float x) -> float\n"
		"  log10(DM x) -> DM\n"
		"  log10(SX x) -> SX\n"
		"  log10(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ph\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L482\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L482-L484\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"log1p", _wrap_log1p, METH_VARARGS, (char *)"\n"
		"  Precision variant for natural logarithm: x -> log(x+1)\n"
		"\n"
		"::\n"
		"\n"
		"  log1p(float x) -> float\n"
		"  log1p(DM x) -> DM\n"
		"  log1p(SX x) -> SX\n"
		"  log1p(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L494\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L494-L496\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expm1", _wrap_expm1, METH_VARARGS, (char *)"\n"
		"  Precision variant for elementwise exponential: x -> exp(x)-1.\n"
		"\n"
		"::\n"
		"\n"
		"  expm1(float x) -> float\n"
		"  expm1(DM x) -> DM\n"
		"  expm1(SX x) -> SX\n"
		"  expm1(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L506\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L506-L508\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"floor", _wrap_floor, METH_VARARGS, (char *)"\n"
		"  Round down to nearest integer: x -> floor(x)\n"
		"\n"
		"::\n"
		"\n"
		"  floor(float x) -> float\n"
		"  floor(DM x) -> DM\n"
		"  floor(SX x) -> SX\n"
		"  floor(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pk\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L518\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L518-L520\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ceil", _wrap_ceil, METH_VARARGS, (char *)"\n"
		"  Round up to nearest integer: x -> ceil(x)\n"
		"\n"
		"::\n"
		"\n"
		"  ceil(float x) -> float\n"
		"  ceil(DM x) -> DM\n"
		"  ceil(SX x) -> SX\n"
		"  ceil(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L530\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L530-L532\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"erf", _wrap_erf, METH_VARARGS, (char *)"\n"
		"  Error function: x -> erf(x)\n"
		"\n"
		"::\n"
		"\n"
		"  erf(float x) -> float\n"
		"  erf(DM x) -> DM\n"
		"  erf(SX x) -> SX\n"
		"  erf(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L542\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L542-L544\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"erfinv", _wrap_erfinv, METH_VARARGS, (char *)"\n"
		"  Inverse error function: x -> erfinv(x)\n"
		"\n"
		"::\n"
		"\n"
		"  erfinv(float x) -> float\n"
		"  erfinv(DM x) -> DM\n"
		"  erfinv(SX x) -> SX\n"
		"  erfinv(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L554\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L554-L556\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sign", _wrap_sign, METH_VARARGS, (char *)"\n"
		"  Sign function:\n"
		"\n"
		"::\n"
		"\n"
		"  sign(float x) -> float\n"
		"  sign(DM x) -> DM\n"
		"  sign(SX x) -> SX\n"
		"  sign(MX x) -> MX\n"
		"\n"
		"\n"
		"sign(x) := -1 for x<0 sign(x) := 1 for x>0, sign(0) := 0 sign(NaN) := \n"
		"NaN\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_po\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L571\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L571-L573\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"power", _wrap_power, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  power(float x, float n) -> float\n"
		"  power(DM x, DM n) -> DM\n"
		"  power(SX x, SX n) -> SX\n"
		"  power(MX x, MX n) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"fmod", _wrap_fmod, METH_VARARGS, (char *)"\n"
		"  Remainder after division: (x,y) -> fmod(x,y)\n"
		"\n"
		"::\n"
		"\n"
		"  fmod(float x, float y) -> float\n"
		"  fmod(DM x, DM y) -> DM\n"
		"  fmod(SX x, SX y) -> SX\n"
		"  fmod(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"This  Function follows the convention of \n"
		"https://en.cppreference.com/w/c/numeric/math/fmod\n"
		"\n"
		"Notably:\n"
		"fmod(5,3) -> 2\n"
		"\n"
		"fmod(5,-3) -> 2\n"
		"\n"
		"fmod(-5,3) -> -2\n"
		"\n"
		"fmod(-5,-3) -> -2\n"
		"\n"
		"This is equivalent to Python's numpy.fmod and Matlab's rem.\n"
		"\n"
		"\\\\seealso remainder\n"
		"\n"
		"::\n"
		"\n"
		"  Extra doc: https://github.com/casadi/casadi/wiki/L_pq \n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L613\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L613-L615\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"remainder", _wrap_remainder, METH_VARARGS, (char *)"\n"
		"  Remainder after division: (x,y) -> remainder(x,y)\n"
		"\n"
		"::\n"
		"\n"
		"  remainder(float x, float y) -> float\n"
		"  remainder(DM x, DM y) -> DM\n"
		"  remainder(SX x, SX y) -> SX\n"
		"  remainder(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"This Function follows the convention of \n"
		"https://en.cppreference.com/w/c/numeric/math/remainder\n"
		"\n"
		"Notably:\n"
		"remainder(5,3) -> -1\n"
		"\n"
		"remainder(5,-3) -> -1\n"
		"\n"
		"remainder(-5,3) -> 1\n"
		"\n"
		"remainder(-5,-3) -> 1\n"
		"\n"
		"This is equivalent to Python's math.remainder. There is no equivalence\n"
		" in \n"
		"Matlab.\n"
		"\n"
		"\\\\seealso fmod\n"
		"\n"
		"::\n"
		"\n"
		"  Extra doc: https://github.com/casadi/casadi/wiki/L_24x \n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L634\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L634-L636\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"atan2", _wrap_atan2, METH_VARARGS, (char *)"\n"
		"  Two argument arc tangent: (y,x) -> atan2(y,x)\n"
		"\n"
		"::\n"
		"\n"
		"  atan2(float x, float y) -> float\n"
		"  atan2(DM x, DM y) -> DM\n"
		"  atan2(SX x, SX y) -> SX\n"
		"  atan2(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"theta = atan2(y,x) corresponds to x = r cos(theta), y = r sin(theta)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L648\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L648-L650\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"fmin", _wrap_fmin, METH_VARARGS, (char *)"\n"
		"  Smallest of two values: (x,y) -> min(x,y)\n"
		"\n"
		"::\n"
		"\n"
		"  fmin(float x, float y) -> float\n"
		"  fmin(DM x, DM y) -> DM\n"
		"  fmin(SX x, SX y) -> SX\n"
		"  fmin(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pt\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L672\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L672-L674\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"fmax", _wrap_fmax, METH_VARARGS, (char *)"\n"
		"  Largest of two values: (x,y) -> max(x,y)\n"
		"\n"
		"::\n"
		"\n"
		"  fmax(float x, float y) -> float\n"
		"  fmax(DM x, DM y) -> DM\n"
		"  fmax(SX x, SX y) -> SX\n"
		"  fmax(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L684\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L684-L686\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"hypot", _wrap_hypot, METH_VARARGS, (char *)"\n"
		"  Precision variant for 2 norm: (x,y) -> sqrt(x^2+y^2)\n"
		"\n"
		"::\n"
		"\n"
		"  hypot(float x, float y) -> float\n"
		"  hypot(DM x, DM y) -> DM\n"
		"  hypot(SX x, SX y) -> SX\n"
		"  hypot(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L742\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L742-L744\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"simplify", _wrap_simplify, METH_VARARGS, (char *)"\n"
		"  Simplify an expression.\n"
		"\n"
		"::\n"
		"\n"
		"  simplify(float x) -> float\n"
		"  simplify(DM x) -> DM\n"
		"  simplify(SX x) -> SX\n"
		"  simplify(MX x) -> MX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L944\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L944-L946\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"is_equal", _wrap_is_equal, METH_VARARGS, (char *)"\n"
		"  Check if two nodes are equivalent up to a given depth.\n"
		"\n"
		"::\n"
		"\n"
		"  is_equal(float x, float y, int depth) -> bool\n"
		"  is_equal(DM x, DM y, int depth) -> bool\n"
		"  is_equal(SX x, SX y, int depth) -> bool\n"
		"  is_equal(MX x, MX y, int depth) -> bool\n"
		"\n"
		"\n"
		"Depth=0 checks if the expressions are identical, i.e. points to the \n"
		"same \n"
		"node.\n"
		"\n"
		"a = x*x b = x*x\n"
		"\n"
		"is_equal(a,b,0) will return false, but a.is_equal(a,b,1) will return \n"
		"true\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_pv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L703\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L703-L705\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"copysign", _wrap_copysign, METH_VARARGS, (char *)"\n"
		"  Copy sign\n"
		"\n"
		"::\n"
		"\n"
		"  copysign(float x, float y) -> float\n"
		"  copysign(DM x, DM y) -> DM\n"
		"  copysign(SX x, SX y) -> SX\n"
		"  copysign(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L710\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L710-L712\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"constpow", _wrap_constpow, METH_VARARGS, (char *)"\n"
		"  Elementwise power with const power\n"
		"\n"
		"::\n"
		"\n"
		"  constpow(float x, float y) -> float\n"
		"  constpow(DM x, DM y) -> DM\n"
		"  constpow(SX x, SX y) -> SX\n"
		"  constpow(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L720\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_expression.hpp#L720-L722\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mpower", _wrap_mpower, METH_VARARGS, (char *)"\n"
		"  Matrix power x^n.\n"
		"\n"
		"::\n"
		"\n"
		"  mpower(DM x, DM n) -> DM\n"
		"  mpower(SX x, SX n) -> SX\n"
		"  mpower(MX x, MX n) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L319\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L319-L321\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mrdivide", _wrap_mrdivide, METH_VARARGS, (char *)"\n"
		"  Matrix divide (cf. slash '/' in MATLAB)\n"
		"\n"
		"::\n"
		"\n"
		"  mrdivide(DM x, DM y) -> DM\n"
		"  mrdivide(SX x, SX y) -> SX\n"
		"  mrdivide(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bl\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L376\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L376-L378\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mldivide", _wrap_mldivide, METH_VARARGS, (char *)"\n"
		"  Matrix divide (cf. backslash '\\\\' in MATLAB)\n"
		"\n"
		"::\n"
		"\n"
		"  mldivide(DM x, DM y) -> DM\n"
		"  mldivide(SX x, SX y) -> SX\n"
		"  mldivide(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L383\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L383-L385\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"symvar", _wrap_symvar, METH_VARARGS, (char *)"\n"
		"  Get symbols present in expression.\n"
		"\n"
		"::\n"
		"\n"
		"  symvar(DM x) -> [DM]\n"
		"  symvar(SX x) -> [SX]\n"
		"  symvar(MX x) -> [MX]\n"
		"\n"
		"\n"
		"Returned vector is ordered according to the order of  variable()/parameter()\n"
		" calls used to create the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L525\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L432-L438\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"bilin", _wrap_bilin, METH_VARARGS, (char *)"\n"
		"  Calculate bilinear/quadratic form x^T A y.\n"
		"\n"
		"::\n"
		"\n"
		"  bilin(DM A, DM x) -> DM\n"
		"  bilin(SX A, SX x) -> SX\n"
		"  bilin(MX A, MX x) -> MX\n"
		"  bilin(DM A, DM x, DM y) -> DM\n"
		"  bilin(SX A, SX x, SX y) -> SX\n"
		"  bilin(MX A, MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"y: \n"
		"can be omitted, in which case x^T A x is calculated\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bo\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L409\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rank1", _wrap_rank1, METH_VARARGS, (char *)"\n"
		"  Make a rank-1 update to a matrix A.\n"
		"\n"
		"::\n"
		"\n"
		"  rank1(DM A, DM alpha, DM x, DM y) -> DM\n"
		"  rank1(SX A, SX alpha, SX x, SX y) -> SX\n"
		"  rank1(MX A, MX alpha, MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Calculates A + 1/2 * alpha * x*y'\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L422\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sumsqr", _wrap_sumsqr, METH_VARARGS, (char *)"\n"
		"  Calculate sum of squares: sum_ij X_ij^2.\n"
		"\n"
		"::\n"
		"\n"
		"  sumsqr(DM X) -> DM\n"
		"  sumsqr(SX X) -> SX\n"
		"  sumsqr(MX X) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L429\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L429-L431\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"linspace", _wrap_linspace, METH_VARARGS, (char *)"\n"
		"  Matlab's linspace.\n"
		"\n"
		"::\n"
		"\n"
		"  linspace(DM a, DM b, int nsteps) -> DM\n"
		"  linspace(SX a, SX b, int nsteps) -> SX\n"
		"  linspace(MX a, MX b, int nsteps) -> MX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L784\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L784-L795\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logsumexp", _wrap_logsumexp, METH_VARARGS, (char *)"\n"
		"  Scaled version of logsumexp.\n"
		"\n"
		"::\n"
		"\n"
		"  logsumexp(DM a) -> DM\n"
		"  logsumexp(SX a) -> SX\n"
		"  logsumexp(MX a) -> MX\n"
		"  logsumexp(DM a, DM margin) -> DM\n"
		"  logsumexp(SX a, SX margin) -> SX\n"
		"  logsumexp(MX a, MX margin) -> MX\n"
		"\n"
		"\n"
		"Scaled such that max(x) <= logsumexp(x, margin) <= max(x)+margin\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L451\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L451-L454\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"interp1d", _wrap_interp1d, METH_VARARGS, (char *)"\n"
		"  Performs 1d linear interpolation.\n"
		"\n"
		"::\n"
		"\n"
		"  interp1d([float] x, DM v, [float] xq, str mode, bool equidistant) -> DM\n"
		"  interp1d([float] x, SX v, [float] xq, str mode, bool equidistant) -> SX\n"
		"  interp1d([float] x, MX v, [float] xq, str mode, bool equidistant) -> MX\n"
		"\n"
		"\n"
		"The data-points to be interpolated are given as (x[i], v[i]). xq[j] is\n"
		" used\n"
		" as interplating value\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L311\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L311-L314\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"soc", _wrap_soc, METH_VARARGS, (char *)"\n"
		"  Construct second-order-convex.\n"
		"\n"
		"::\n"
		"\n"
		"  soc(DM x, DM y) -> DM\n"
		"  soc(SX x, SX y) -> SX\n"
		"  soc(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"x: \n"
		"vector expression of size n\n"
		"\n"
		"y: \n"
		"scalar expression\n"
		"\n"
		"soc(x,y) computes [y*eye(n) x; x' y]\n"
		"\n"
		"soc(x,y) positive semi definite <=> || x ||_2 <= y\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L334\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L334-L336\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cross", _wrap_cross, METH_VARARGS, (char *)"\n"
		"  Matlab's  cross command.\n"
		"\n"
		"::\n"
		"\n"
		"  cross(DM a, DM b, int dim) -> DM\n"
		"  cross(SX a, SX b, int dim) -> SX\n"
		"  cross(MX a, MX b, int dim) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L467\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L467-L469\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"skew", _wrap_skew, METH_VARARGS, (char *)"\n"
		"  Generate a skew symmetric matrix from a 3-vector.\n"
		"\n"
		"::\n"
		"\n"
		"  skew(DM a) -> DM\n"
		"  skew(SX a) -> SX\n"
		"  skew(MX a) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L474\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L474-L476\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"inv_skew", _wrap_inv_skew, METH_VARARGS, (char *)"\n"
		"  Generate the 3-vector progenitor of a skew symmetric matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  inv_skew(DM a) -> DM\n"
		"  inv_skew(SX a) -> SX\n"
		"  inv_skew(MX a) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L481\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L481-L483\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"det", _wrap_det, METH_VARARGS, (char *)"\n"
		"  Matrix determinant (experimental)\n"
		"\n"
		"::\n"
		"\n"
		"  det(DM A) -> DM\n"
		"  det(SX A) -> SX\n"
		"  det(MX A) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1bx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L488\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L488-L488\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"inv_minor", _wrap_inv_minor, METH_VARARGS, (char *)"\n"
		"  Matrix inverse (experimental)\n"
		"\n"
		"::\n"
		"\n"
		"  inv_minor(DM A) -> DM\n"
		"  inv_minor(SX A) -> SX\n"
		"  inv_minor(MX A) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1by\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L493\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L493-L493\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"inv", _wrap_inv, METH_VARARGS, (char *)"\n"
		"  Element-wise inverse.\n"
		"\n"
		"::\n"
		"\n"
		"  inv(DM A) -> DM\n"
		"  inv(SX A) -> SX\n"
		"  inv(MX A) -> MX\n"
		"  inv(DM A, str lsolver, dict opts) -> DM\n"
		"  inv(SX A, str lsolver, dict opts) -> SX\n"
		"  inv(MX A, str lsolver, dict opts) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_10y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L222\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.cpp#L159-L165\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"trace", _wrap_trace, METH_VARARGS, (char *)"\n"
		"  Matrix trace.\n"
		"\n"
		"::\n"
		"\n"
		"  trace(DM a) -> DM\n"
		"  trace(SX a) -> SX\n"
		"  trace(MX a) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L514-L514\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"tril2symm", _wrap_tril2symm, METH_VARARGS, (char *)"\n"
		"  Convert a lower triangular matrix to a symmetric one.\n"
		"\n"
		"::\n"
		"\n"
		"  tril2symm(DM a) -> DM\n"
		"  tril2symm(SX a) -> SX\n"
		"  tril2symm(MX a) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L519\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L519-L519\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"triu2symm", _wrap_triu2symm, METH_VARARGS, (char *)"\n"
		"  Convert a upper triangular matrix to a symmetric one.\n"
		"\n"
		"::\n"
		"\n"
		"  triu2symm(DM a) -> DM\n"
		"  triu2symm(SX a) -> SX\n"
		"  triu2symm(MX a) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L524\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L524-L524\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_fro", _wrap_norm_fro, METH_VARARGS, (char *)"\n"
		"  Frobenius norm.\n"
		"\n"
		"::\n"
		"\n"
		"  norm_fro(DM x) -> DM\n"
		"  norm_fro(SX x) -> SX\n"
		"  norm_fro(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L529\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L529-L529\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_2", _wrap_norm_2, METH_VARARGS, (char *)"\n"
		"  2-norm\n"
		"\n"
		"::\n"
		"\n"
		"  norm_2(DM x) -> DM\n"
		"  norm_2(SX x) -> SX\n"
		"  norm_2(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L534\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L534-L534\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_1", _wrap_norm_1, METH_VARARGS, (char *)"\n"
		"  1-norm\n"
		"\n"
		"::\n"
		"\n"
		"  norm_1(DM x) -> DM\n"
		"  norm_1(SX x) -> SX\n"
		"  norm_1(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L539\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L539-L539\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_inf", _wrap_norm_inf, METH_VARARGS, (char *)"\n"
		"  Infinity-norm.\n"
		"\n"
		"::\n"
		"\n"
		"  norm_inf(DM x) -> DM\n"
		"  norm_inf(SX x) -> SX\n"
		"  norm_inf(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L544\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L544-L544\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dot", _wrap_dot, METH_VARARGS, (char *)"\n"
		"  Inner product of two matrices.\n"
		"\n"
		"::\n"
		"\n"
		"  dot(DM x, DM y) -> DM\n"
		"  dot(SX x, SX y) -> SX\n"
		"  dot(MX x, MX y) -> MX\n"
		"\n"
		"\n"
		"with x and y matrices of the same dimension\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ca\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L565\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L565-L567\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"nullspace", _wrap_nullspace, METH_VARARGS, (char *)"\n"
		"  Computes the nullspace of a matrix A.\n"
		"\n"
		"::\n"
		"\n"
		"  nullspace(DM A) -> DM\n"
		"  nullspace(SX A) -> SX\n"
		"  nullspace(MX A) -> MX\n"
		"\n"
		"\n"
		"Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n\n"
		"\n"
		"Assumes A is full rank\n"
		"\n"
		"Inspired by Numerical Methods in Scientific Computing by Ake Bjorck\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cb\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L579\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L579-L581\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"polyval", _wrap_polyval, METH_VARARGS, (char *)"\n"
		"  Evaluate a polynomial with coefficients p in x.\n"
		"\n"
		"::\n"
		"\n"
		"  polyval(DM p, DM x) -> DM\n"
		"  polyval(SX p, SX x) -> SX\n"
		"  polyval(MX p, MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L586\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L586-L588\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"diag", _wrap_diag, METH_VARARGS, (char *)"\n"
		"  Get the diagonal of a matrix or construct a diagonal.\n"
		"\n"
		"::\n"
		"\n"
		"  diag(DM A) -> DM\n"
		"  diag(SX A) -> SX\n"
		"  diag(MX A) -> MX\n"
		"\n"
		"\n"
		"When the input is square, the diagonal elements are returned. If the \n"
		"input \n"
		"is vector-like, a diagonal matrix is constructed with it.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cd\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L596\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L596-L598\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"unite", _wrap_unite, METH_VARARGS, (char *)"\n"
		"  Unite two matrices no overlapping sparsity.\n"
		"\n"
		"::\n"
		"\n"
		"  unite(DM A, DM B) -> DM\n"
		"  unite(SX A, SX B) -> SX\n"
		"  unite(MX A, MX B) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ce\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L603\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L603-L605\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"densify", _wrap_densify, METH_VARARGS, (char *)"\n"
		"  Make the matrix dense and assign nonzeros to a value.\n"
		"\n"
		"::\n"
		"\n"
		"  densify(DM x) -> DM\n"
		"  densify(SX x) -> SX\n"
		"  densify(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cg\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L617\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L617-L619\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"project", _wrap_project, METH_VARARGS, (char *)"\n"
		"  Create a new matrix with a given sparsity pattern but with the.\n"
		"\n"
		"::\n"
		"\n"
		"  project(DM A, Sparsity sp, bool intersect) -> DM\n"
		"  project(SX A, Sparsity sp, bool intersect) -> SX\n"
		"  project(MX A, Sparsity sp, bool intersect) -> MX\n"
		"\n"
		"\n"
		"nonzeros taken from an existing matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ch\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L626\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L626-L629\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"if_else", _wrap_if_else, METH_VARARGS, (char *)"\n"
		"  Ternary if_else: x ? y : z.\n"
		"\n"
		"::\n"
		"\n"
		"  if_else(DM cond, DM if_true, DM if_false, bool short_circuit) -> DM\n"
		"  if_else(SX cond, SX if_true, SX if_false, bool short_circuit) -> SX\n"
		"  if_else(MX cond, MX if_true, MX if_false, bool short_circuit) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_113\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L265\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sx_elem.hpp#L265-L267\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"conditional", _wrap_conditional, METH_VARARGS, (char *)"\n"
		"  Create a switch.\n"
		"\n"
		"::\n"
		"\n"
		"  conditional(DM ind, [DM] x, DM x_default, bool short_circuit) -> DM\n"
		"  conditional(SX ind, [SX] x, SX x_default, bool short_circuit) -> SX\n"
		"  conditional(MX ind, [MX] x, MX x_default, bool short_circuit) -> MX\n"
		"\n"
		"\n"
		"If the condition\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"ind: \n"
		"evaluates to the integer k, where 0<=k<f.size(), then x[k] will be \n"
		"\n"
		"returned, otherwise\n"
		"\n"
		"x_default: \n"
		"will be returned.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L647\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L647-L650\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"depends_on", _wrap_depends_on, METH_VARARGS, (char *)"\n"
		"  Check if expression depends on the argument.\n"
		"\n"
		"::\n"
		"\n"
		"  depends_on(DM f, DM arg) -> bool\n"
		"  depends_on(SX f, SX arg) -> bool\n"
		"  depends_on(MX f, MX arg) -> bool\n"
		"\n"
		"\n"
		"The argument must be symbolic\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ck\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L657\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L657-L659\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"solve", _wrap_solve, METH_VARARGS, (char *)"\n"
		"  Crunch the numbers; solve the problem.\n"
		"\n"
		"::\n"
		"\n"
		"  solve(DM A, DM b) -> DM\n"
		"  solve(SX A, SX b) -> SX\n"
		"  solve(MX A, MX b) -> MX\n"
		"  solve(DM A, DM b, str lsolver, dict opts) -> DM\n"
		"  solve(SX A, SX b, str lsolver, dict opts) -> SX\n"
		"  solve(MX A, MX b, str lsolver, dict opts) -> MX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L204\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L153-L159\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"pinv", _wrap_pinv, METH_VARARGS, (char *)"\n"
		"  Computes the Moore-Penrose pseudo-inverse.\n"
		"\n"
		"::\n"
		"\n"
		"  pinv(DM A) -> DM\n"
		"  pinv(SX A) -> SX\n"
		"  pinv(MX A) -> MX\n"
		"  pinv(DM A, str lsolver, dict opts) -> DM\n"
		"  pinv(SX A, str lsolver, dict opts) -> SX\n"
		"  pinv(MX A, str lsolver, dict opts) -> MX\n"
		"\n"
		"\n"
		"If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the\n"
		"\n"
		"matrix A is slender (size2<size1), mul(pinv(A), A) is unity.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cu\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L767\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L767-L770\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expm_const", _wrap_expm_const, METH_VARARGS, (char *)"\n"
		"  Calculate  Matrix exponential.\n"
		"\n"
		"::\n"
		"\n"
		"  expm_const(DM A, DM t) -> DM\n"
		"  expm_const(SX A, SX t) -> SX\n"
		"  expm_const(MX A, MX t) -> MX\n"
		"\n"
		"\n"
		"Computes expm(A*t) with A constant\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"A[in]: \n"
		"Square matrix\n"
		"\n"
		"t[in]: \n"
		"Scalar\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23v\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L782\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L782-L784\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expm", _wrap_expm, METH_VARARGS, (char *)"\n"
		"  Calculate  Matrix exponential.\n"
		"\n"
		"::\n"
		"\n"
		"  expm(DM A) -> DM\n"
		"  expm(SX A) -> SX\n"
		"  expm(MX A) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L790\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L790-L792\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"jacobian", _wrap_jacobian, METH_VARARGS, (char *)"\n"
		"  Calculate Jacobian.\n"
		"\n"
		"::\n"
		"\n"
		"  jacobian(DM ex, DM arg, dict opts) -> DM\n"
		"  jacobian(SX ex, SX arg, dict opts) -> SX\n"
		"  jacobian(MX ex, MX arg, dict opts) -> MX\n"
		"\n"
		"\n"
		"Sparse matrix\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L799\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L799-L802\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"jtimes", _wrap_jtimes, METH_VARARGS, (char *)"\n"
		"  Calculate the Jacobian and multiply by a vector from the right.\n"
		"\n"
		"::\n"
		"\n"
		"  jtimes(DM ex, DM arg, DM v, bool tr) -> DM\n"
		"  jtimes(SX ex, SX arg, SX v, bool tr) -> SX\n"
		"  jtimes(MX ex, MX arg, MX v, bool tr) -> MX\n"
		"\n"
		"\n"
		"This is equivalent to  mul(jacobian(ex, arg), v) or  mul(jacobian(ex, \n"
		"arg).T, v) for tr set to false and true respectively. If contrast to these \n"
		"\n"
		"expressions, it will use directional derivatives which is typically \n"
		"(but \n"
		"not necessarily) more efficient if the complete Jacobian is not \n"
		"needed and \n"
		"v has few rows.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L832\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L832-L835\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"linearize", _wrap_linearize, METH_VARARGS, (char *)"\n"
		"  Linearize an expression.\n"
		"\n"
		"::\n"
		"\n"
		"  linearize(DM f, DM x, DM x0) -> DM\n"
		"  linearize(SX f, SX x, SX x0) -> SX\n"
		"  linearize(MX f, MX x, MX x0) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cs\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L740\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L740-L743\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"which_depends", _wrap_which_depends, METH_VARARGS, (char *)"\n"
		"  Find out which variables enter with some order.\n"
		"\n"
		"::\n"
		"\n"
		"  which_depends(DM expr, DM var, int order, bool tr) -> [bool]\n"
		"  which_depends(SX expr, SX var, int order, bool tr) -> [bool]\n"
		"  which_depends(MX expr, MX var, int order, bool tr) -> [bool]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cz\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L874\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L874-L877\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"jacobian_sparsity", _wrap_jacobian_sparsity, METH_VARARGS, (char *)"\n"
		"  Get the sparsity pattern of a jacobian.\n"
		"\n"
		"::\n"
		"\n"
		"  jacobian_sparsity(DM f, DM x) -> Sparsity\n"
		"  jacobian_sparsity(SX f, SX x) -> Sparsity\n"
		"  jacobian_sparsity(MX f, MX x) -> Sparsity\n"
		"\n"
		"\n"
		"Equivalent to, but cheaper to compute than, jacobian(f,x). sparsity()\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_259\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L884\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L884-L886\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"is_linear", _wrap_is_linear, METH_VARARGS, (char *)"\n"
		"  Is expr linear in var?\n"
		"\n"
		"::\n"
		"\n"
		"  is_linear(DM expr, DM var) -> bool\n"
		"  is_linear(SX expr, SX var) -> bool\n"
		"  is_linear(MX expr, MX var) -> bool\n"
		"\n"
		"\n"
		"False negatives are possible (an expression may not be recognised as \n"
		"linear\n"
		" while it really is), false positives not.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L895\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L895-L897\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"is_quadratic", _wrap_is_quadratic, METH_VARARGS, (char *)"\n"
		"  Is expr quadratic in var?\n"
		"\n"
		"::\n"
		"\n"
		"  is_quadratic(DM expr, DM var) -> bool\n"
		"  is_quadratic(SX expr, SX var) -> bool\n"
		"  is_quadratic(MX expr, MX var) -> bool\n"
		"\n"
		"\n"
		"False negatives are possible (an expression may not be recognised as \n"
		"\n"
		"quadratic while it really is), false positives not.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d1\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L906\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L906-L908\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"gradient", _wrap_gradient, METH_VARARGS, (char *)"\n"
		"  Calculate the gradient of an expression.\n"
		"\n"
		"::\n"
		"\n"
		"  gradient(DM ex, DM arg) -> DM\n"
		"  gradient(SX ex, SX arg) -> SX\n"
		"  gradient(MX ex, MX arg) -> MX\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"ex[in]: \n"
		"Scalar expression to take the gradient of\n"
		"\n"
		"arg[in]: \n"
		"Vector expression of symbols\n"
		"\n"
		"opts[in]: \n"
		"Options\n"
		"\n"
		"Dense column vector\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L812\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L812-L814\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"tangent", _wrap_tangent, METH_VARARGS, (char *)"\n"
		"  Calculate the tangent of an expression.\n"
		"\n"
		"::\n"
		"\n"
		"  tangent(DM ex, DM arg) -> DM\n"
		"  tangent(SX ex, SX arg) -> SX\n"
		"  tangent(MX ex, MX arg) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L819\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L819-L821\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"hessian", _wrap_hessian, METH_VARARGS, (char *)"\n"
		"  Hessian and (optionally) gradient.\n"
		"\n"
		"::\n"
		"\n"
		"  hessian(DM ex, DM arg, dict opts) -> (DM , DM OUTPUT1)\n"
		"  hessian(SX ex, SX arg, dict opts) -> (SX , SX OUTPUT1)\n"
		"  hessian(MX ex, MX arg, dict opts) -> (MX , MX OUTPUT1)\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L865\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L865-L868\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"quadratic_coeff", _wrap_quadratic_coeff, METH_VARARGS, (char *)"\n"
		"  Recognizes quadratic form in scalar expression.\n"
		"\n"
		"::\n"
		"\n"
		"  quadratic_coeff(DM ex, DM arg, bool check) -> (DM OUTPUT1, DM OUTPUT2, DM OUTPUT3)\n"
		"  quadratic_coeff(SX ex, SX arg, bool check) -> (SX OUTPUT1, SX OUTPUT2, SX OUTPUT3)\n"
		"  quadratic_coeff(MX ex, MX arg, bool check) -> (MX OUTPUT1, MX OUTPUT2, MX OUTPUT3)\n"
		"\n"
		"\n"
		"1/2*x' A x + b' x + c\n"
		"\n"
		"e = 0.5*bilin(A,x,x)+dot(b,x)+c\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"check[in]: \n"
		"When true (default), A is checked to be independent of x. \n"
		"Provided to \n"
		"deal with false positive dependency checks.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L920\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L920-L923\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"linear_coeff", _wrap_linear_coeff, METH_VARARGS, (char *)"\n"
		"  Recognizes linear form in vector expression.\n"
		"\n"
		"::\n"
		"\n"
		"  linear_coeff(DM ex, DM arg, bool check) -> (DM OUTPUT1, DM OUTPUT2)\n"
		"  linear_coeff(SX ex, SX arg, bool check) -> (SX OUTPUT1, SX OUTPUT2)\n"
		"  linear_coeff(MX ex, MX arg, bool check) -> (MX OUTPUT1, MX OUTPUT2)\n"
		"\n"
		"\n"
		"A x + b\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"check[in]: \n"
		"When true (default)m, A is checked to be independent of x. \n"
		"Provided to\n"
		" deal with false positive dependency checks.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L933\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L933-L936\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"n_nodes", _wrap_n_nodes, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  n_nodes(DM A) -> int\n"
		"  n_nodes(SX A) -> int\n"
		"  n_nodes(MX A) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"print_operator", _wrap_print_operator, METH_VARARGS, (char *)"\n"
		"  Get a string representation for a binary MatType, using custom \n"
		"\n"
		"::\n"
		"\n"
		"  print_operator(DM xb, [str] args) -> str\n"
		"  print_operator(SX xb, [str] args) -> str\n"
		"  print_operator(MX xb, [str] args) -> str\n"
		"\n"
		"arguments.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L952\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L952-L954\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"repsum", _wrap_repsum, METH_VARARGS, (char *)"\n"
		"  Given a repeated matrix, computes the sum of repeated parts.\n"
		"\n"
		"::\n"
		"\n"
		"  repsum(DM A, int n, int m) -> DM\n"
		"  repsum(SX A, int n, int m) -> SX\n"
		"  repsum(MX A, int n, int m) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L980\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L980-L982\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"diff", _wrap_diff, METH_VARARGS, (char *)"\n"
		"  diff\n"
		"\n"
		"::\n"
		"\n"
		"  diff(DM A, int n, int axis) -> DM\n"
		"  diff(SX A, int n, int axis) -> SX\n"
		"  diff(MX A, int n, int axis) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ln\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L886\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L886-L893\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cumsum", _wrap_cumsum, METH_VARARGS, (char *)"\n"
		"  cumulative sum\n"
		"\n"
		"::\n"
		"\n"
		"  cumsum(DM A, int axis) -> DM\n"
		"  cumsum(SX A, int axis) -> SX\n"
		"  cumsum(MX A, int axis) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1lm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L864\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L864-L872\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"einstein", _wrap_einstein, METH_VARARGS, (char *)"\n"
		"  Computes an einstein dense tensor contraction.\n"
		"\n"
		"::\n"
		"\n"
		"  einstein(DM A, DM B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> DM\n"
		"  einstein(SX A, SX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> SX\n"
		"  einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX\n"
		"  einstein(DM A, DM B, DM C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> DM\n"
		"  einstein(SX A, SX B, SX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> SX\n"
		"  einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX\n"
		"\n"
		"\n"
		"Computes the product: C_c = A_a + B_b where a b c are index/einstein \n"
		"\n"
		"notation in an encoded form\n"
		"\n"
		"For example, an matrix-matrix product may be written as: C_ij = A_ik \n"
		"B_kj\n"
		"\n"
		"The encoded form uses strictly negative numbers to indicate labels. \n"
		"For the\n"
		" above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L520\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.cpp#L646-L652\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mmin", _wrap_mmin, METH_VARARGS, (char *)"\n"
		"  Smallest element in a matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  mmin(DM x) -> DM\n"
		"  mmin(SX x) -> SX\n"
		"  mmin(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L988\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L988-L990\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mmax", _wrap_mmax, METH_VARARGS, (char *)"\n"
		"  Largest element in a matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  mmax(DM x) -> DM\n"
		"  mmax(SX x) -> SX\n"
		"  mmax(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L997\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L997-L999\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"evalf", _wrap_evalf, METH_VARARGS, (char *)"\n"
		"  Evaluates the expression numerically.\n"
		"\n"
		"::\n"
		"\n"
		"  evalf(DM x) -> DM\n"
		"  evalf(SX x) -> DM\n"
		"  evalf(MX x) -> DM\n"
		"\n"
		"\n"
		"An error is raised when the expression contains symbols\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rf\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L802\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L802-L804\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cse", _wrap_cse, METH_VARARGS, (char *)"\n"
		"  Common subexpression elimination.\n"
		"\n"
		"::\n"
		"\n"
		"  cse(DM e) -> DM\n"
		"  cse([DM] e) -> [DM]\n"
		"  cse([SX] e) -> [SX]\n"
		"  cse(SX e) -> SX\n"
		"  cse(MX e) -> MX\n"
		"  cse([MX] e) -> [MX]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L702\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L702-L704\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"forward", _wrap_forward, METH_VARARGS, (char *)"\n"
		"  Forward directional derivative.\n"
		"\n"
		"::\n"
		"\n"
		"  forward([DM] ex, [DM] arg, [[DM]] v, dict opts) -> [[DM]]\n"
		"  forward([SX] ex, [SX] arg, [[SX]] v, dict opts) -> [[SX]]\n"
		"  forward([MX] ex, [MX] arg, [[MX]] v, dict opts) -> [[MX]]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cx\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L841\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L841-L845\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"reverse", _wrap_reverse, METH_VARARGS, (char *)"\n"
		"  Reverse a list.\n"
		"\n"
		"::\n"
		"\n"
		"  reverse([DM] ex, [DM] arg, [[DM]] v, dict opts) -> [[DM]]\n"
		"  reverse([SX] ex, [SX] arg, [[SX]] v, dict opts) -> [[SX]]\n"
		"  reverse([MX] ex, [MX] arg, [[MX]] v, dict opts) -> [[MX]]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1la\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L530\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L530-L534\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"substitute", _wrap_substitute, METH_VARARGS, (char *)"\n"
		"  Substitute variable var with expression expr in multiple expressions.\n"
		"\n"
		"::\n"
		"\n"
		"  substitute(DM ex, DM v, DM vdef) -> DM\n"
		"  substitute([DM] ex, [DM] v, [DM] vdef) -> [DM]\n"
		"  substitute(SX ex, SX v, SX vdef) -> SX\n"
		"  substitute([SX] ex, [SX] v, [SX] vdef) -> [SX]\n"
		"  substitute(MX ex, MX v, MX vdef) -> MX\n"
		"  substitute([MX] ex, [MX] v, [MX] vdef) -> [MX]\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cm\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L673\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L673-L676\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"substitute_inplace", _wrap_substitute_inplace, METH_VARARGS, (char *)"\n"
		"  Inplace substitution with piggyback expressions.\n"
		"\n"
		"::\n"
		"\n"
		"  substitute_inplace([DM] v, bool reverse) -> ([DM] INOUT1, [DM] INOUT2)\n"
		"  substitute_inplace([SX] v, bool reverse) -> ([SX] INOUT1, [SX] INOUT2)\n"
		"  substitute_inplace([MX] v, bool reverse) -> ([MX] INOUT1, [MX] INOUT2)\n"
		"\n"
		"\n"
		"Substitute variables v out of the expressions vdef sequentially, as \n"
		"well as\n"
		" out of a number of other expressions piggyback\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1cn\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L685\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L685-L689\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"extract", _wrap_extract, METH_VARARGS, (char *)"\n"
		"  Introduce intermediate variables for selected nodes in a graph.\n"
		"\n"
		"::\n"
		"\n"
		"  extract([DM] ex, dict opts) -> ([DM] OUTPUT1, [DM] OUTPUT2, [DM] OUTPUT3)\n"
		"  extract([SX] ex, dict opts) -> ([SX] OUTPUT1, [SX] OUTPUT2, [SX] OUTPUT3)\n"
		"  extract([MX] ex, dict opts) -> ([MX] OUTPUT1, [MX] OUTPUT2, [MX] OUTPUT3)\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L959\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/generic_matrix.hpp#L959-L964\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"shared", _wrap_shared, METH_VARARGS, (char *)"\n"
		"  Get a shared (owning) reference.\n"
		"\n"
		"::\n"
		"\n"
		"  shared([DM] ex, str v_prefix, str v_suffix) -> ([DM] OUTPUT1, [DM] OUTPUT2, [DM] OUTPUT3)\n"
		"  shared([SX] ex, str v_prefix, str v_suffix) -> ([SX] OUTPUT1, [SX] OUTPUT2, [SX] OUTPUT3)\n"
		"  shared([MX] ex, str v_prefix, str v_suffix) -> ([MX] OUTPUT1, [MX] OUTPUT2, [MX] OUTPUT3)\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_b0\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.hpp#L198\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/shared_object.cpp#L141-L147\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"blockcat", _wrap_blockcat, METH_VARARGS, (char *)"\n"
		"  Construct a matrix from 4 blocks.\n"
		"\n"
		"::\n"
		"\n"
		"  blockcat([[DM]] v) -> DM\n"
		"  blockcat([[SX]] v) -> SX\n"
		"  blockcat([[MX]] v) -> MX\n"
		"  blockcat(Sparsity A, Sparsity B, Sparsity C, Sparsity D) -> Sparsity\n"
		"  blockcat(DM A, DM B, DM C, DM D) -> DM\n"
		"  blockcat(SX A, SX B, SX C, SX D) -> SX\n"
		"  blockcat(MX A, MX B, MX C, MX D) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_3m\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L234\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/sparsity_interface.hpp#L234-L236\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logic_all", _wrap_logic_all, METH_VARARGS, (char *)"\n"
		"  Check if all arguments are true.\n"
		"\n"
		"::\n"
		"\n"
		"  logic_all(DM x) -> DM\n"
		"  logic_all(SX x) -> SX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L76\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.cpp#L76-L81\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"logic_any", _wrap_logic_any, METH_VARARGS, (char *)"\n"
		"  Check if any arguments are true.\n"
		"\n"
		"::\n"
		"\n"
		"  logic_any(DM x) -> DM\n"
		"  logic_any(SX x) -> SX\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L83\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.cpp#L83-L88\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"adj", _wrap_adj, METH_VARARGS, (char *)"\n"
		"  Matrix adjoint.\n"
		"\n"
		"::\n"
		"\n"
		"  adj(DM A) -> DM\n"
		"  adj(SX A) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L504\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L504-L506\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"minor", _wrap_minor, METH_VARARGS, (char *)"\n"
		"  Get the (i,j) minor matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  minor(DM x, int i, int j) -> DM\n"
		"  minor(SX x, int i, int j) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L511\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L511-L513\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"cofactor", _wrap_cofactor, METH_VARARGS, (char *)"\n"
		"  Get the (i,j) cofactor matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  cofactor(DM x, int i, int j) -> DM\n"
		"  cofactor(SX x, int i, int j) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L518\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L518-L520\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"qr", _wrap_qr, METH_VARARGS, (char *)"\n"
		"  QR factorization using the modified Gram-Schmidt algorithm.\n"
		"\n"
		"::\n"
		"\n"
		"  qr(DM A) -> (DM OUTPUT1, DM OUTPUT2)\n"
		"  qr(SX A) -> (SX OUTPUT1, SX OUTPUT2)\n"
		"\n"
		"\n"
		"More stable than the classical Gram-Schmidt, but may break down if the\n"
		" rows\n"
		" of A are nearly linearly dependent See J. Demmel: Applied \n"
		"Numerical Linear\n"
		" Algebra (algorithm 3.1.). Note that in SWIG, Q and R \n"
		"are returned by \n"
		"value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18s\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L530\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L530-L532\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"qr_sparse", _wrap_qr_sparse, METH_VARARGS, (char *)"\n"
		"  Sparse direct QR factorization.\n"
		"\n"
		"::\n"
		"\n"
		"  qr_sparse(DM A, bool amd) -> (DM OUTPUT1, DM OUTPUT2, DM OUTPUT3, [int] OUTPUT4, [int] OUTPUT5)\n"
		"  qr_sparse(SX A, bool amd) -> (SX OUTPUT1, SX OUTPUT2, SX OUTPUT3, [int] OUTPUT4, [int] OUTPUT5)\n"
		"\n"
		"\n"
		"See T. Davis: Direct Methods for Sparse Linear Systems\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L539\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L539-L543\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"qr_solve", _wrap_qr_solve, METH_VARARGS, (char *)"\n"
		"  Solve using a sparse QR factorization.\n"
		"\n"
		"::\n"
		"\n"
		"  qr_solve(DM b, DM v, DM r, DM beta, [int] prinv, [int] pc, bool tr) -> DM\n"
		"  qr_solve(SX b, SX v, SX r, SX beta, [int] prinv, [int] pc, bool tr) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L549\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L549-L554\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ldl", _wrap_ldl, METH_VARARGS, (char *)"\n"
		"  Sparse LDL^T factorization.\n"
		"\n"
		"::\n"
		"\n"
		"  ldl(DM A, bool amd) -> (DM OUTPUT1, DM OUTPUT2, [int] OUTPUT3)\n"
		"  ldl(SX A, bool amd) -> (SX OUTPUT1, SX OUTPUT2, [int] OUTPUT3)\n"
		"\n"
		"\n"
		"Returns D and the strictly upper triangular entries of L^T I.e. ones \n"
		"on the\n"
		" diagonal are ignored. Only guarenteed to work for positive \n"
		"definite \n"
		"matrices.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L573\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L573-L576\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ldl_solve", _wrap_ldl_solve, METH_VARARGS, (char *)"\n"
		"  Solve using a sparse LDL^T factorization.\n"
		"\n"
		"::\n"
		"\n"
		"  ldl_solve(DM b, DM D, DM LT, [int] p) -> DM\n"
		"  ldl_solve(SX b, SX D, SX LT, [int] p) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L582\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L582-L585\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"chol", _wrap_chol, METH_VARARGS, (char *)"\n"
		"  Obtain a Cholesky factorisation of a matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  chol(DM A) -> DM\n"
		"  chol(SX A) -> SX\n"
		"\n"
		"\n"
		"Performs and LDL transformation [L,D] = ldl(A) and returns \n"
		"diag(sqrt(D))*L'\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18v\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L562\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L562-L564\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"norm_inf_mul", _wrap_norm_inf_mul, METH_VARARGS, (char *)"\n"
		"  Inf-norm of a Matrix-Matrix product.\n"
		"\n"
		"::\n"
		"\n"
		"  norm_inf_mul(DM x, DM y) -> DM\n"
		"  norm_inf_mul(SX x, SX y) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_190\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L605\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L605-L607\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"sparsify", _wrap_sparsify, METH_VARARGS, (char *)"\n"
		"  Make a matrix sparse by removing numerical zeros.\n"
		"\n"
		"::\n"
		"\n"
		"  sparsify(DM A, float tol) -> DM\n"
		"  sparsify(SX A, float tol) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_191\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L613\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L613-L615\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"expand", _wrap_expand, METH_VARARGS, (char *)"\n"
		"  Expand the expression as a weighted sum (with constant weights)\n"
		"\n"
		"::\n"
		"\n"
		"  expand(DM ex) -> (DM OUTPUT1, DM OUTPUT2)\n"
		"  expand(SX ex) -> (SX OUTPUT1, SX OUTPUT2)\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_192\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L620\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L620-L623\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"pw_const", _wrap_pw_const, METH_VARARGS, (char *)"\n"
		"  Create a piecewise constant function.\n"
		"\n"
		"::\n"
		"\n"
		"  pw_const(DM t, DM tval, DM val) -> DM\n"
		"  pw_const(SX t, SX tval, SX val) -> SX\n"
		"\n"
		"\n"
		"Create a piecewise constant function with n=val.size() intervals\n"
		"\n"
		"Inputs:\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"t: \n"
		"a scalar variable (e.g. time)\n"
		"\n"
		"tval: \n"
		"vector with the discrete values of t at the interval transitions \n"
		"\n"
		"(length n-1)\n"
		"\n"
		"val: \n"
		"vector with the value of the function for each interval (length n)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_193\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L635\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L635-L639\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"pw_lin", _wrap_pw_lin, METH_VARARGS, (char *)"\n"
		"  t a scalar variable (e.g. time)\n"
		"\n"
		"::\n"
		"\n"
		"  pw_lin(DM t, DM tval, DM val) -> DM\n"
		"  pw_lin(SX t, SX tval, SX val) -> SX\n"
		"\n"
		"\n"
		"Create a piecewise linear function\n"
		"\n"
		"Create a piecewise linear function:\n"
		"\n"
		"Inputs:\n"
		"\n"
		"tval vector with the the discrete values of t (monotonically \n"
		"increasing)\n"
		"\n"
		"val vector with the corresponding function values (same length as \n"
		"tval)\n"
		"\n"
		"::\n"
		"\n"
		"                                                                                                      Extra doc: https://github.com/casadi/casadi/wiki/L_194 \n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L652\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L652-L655\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"heaviside", _wrap_heaviside, METH_VARARGS, (char *)"\n"
		"  Heaviside function.\n"
		"\n"
		"::\n"
		"\n"
		"  heaviside(DM x) -> DM\n"
		"  heaviside(SX x) -> SX\n"
		"\n"
		"\n"
		"\\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \n"
		"\\\\\\\\ \n"
		"H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_195\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L668\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L668-L670\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"rectangle", _wrap_rectangle, METH_VARARGS, (char *)"\n"
		"  rectangle function\n"
		"\n"
		"::\n"
		"\n"
		"  rectangle(DM x) -> DM\n"
		"  rectangle(SX x) -> SX\n"
		"\n"
		"\n"
		"\\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) =\n"
		" 1/2 \n"
		"& |x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end \n"
		"{cases} \n"
		"\\\\]\n"
		"\n"
		"Also called: gate function, block function, band function, pulse \n"
		"function, \n"
		"window function\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23n\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L685\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L685-L687\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"triangle", _wrap_triangle, METH_VARARGS, (char *)"\n"
		"  triangle function\n"
		"\n"
		"::\n"
		"\n"
		"  triangle(DM x) -> DM\n"
		"  triangle(SX x) -> SX\n"
		"\n"
		"\n"
		"\\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \n"
		"\\\\Lambda(x)\n"
		" = 1-|x| & |x| < 1 \\\\end {cases} \\\\]\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L700\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L700-L702\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"ramp", _wrap_ramp, METH_VARARGS, (char *)"\n"
		"  ramp function\n"
		"\n"
		"::\n"
		"\n"
		"  ramp(DM x) -> DM\n"
		"  ramp(SX x) -> SX\n"
		"\n"
		"\n"
		"\\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \n"
		"\n"
		"\\\\\\\\ \\\\end {cases} \\\\]\n"
		"\n"
		"Also called: slope function\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L717\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L717-L719\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"gauss_quadrature", _wrap_gauss_quadrature, METH_VARARGS, (char *)"\n"
		"  Integrate f from a to b using Gaussian quadrature with n points.\n"
		"\n"
		"::\n"
		"\n"
		"  gauss_quadrature(DM f, DM x, DM a, DM b, int order) -> DM\n"
		"  gauss_quadrature(SX f, SX x, SX a, SX b, int order) -> SX\n"
		"  gauss_quadrature(DM f, DM x, DM a, DM b, int order, DM w) -> DM\n"
		"  gauss_quadrature(SX f, SX x, SX a, SX b, int order, SX w) -> SX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_196\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L732\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L732-L736\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"taylor", _wrap_taylor, METH_VARARGS, (char *)"\n"
		"  univariate Taylor series expansion\n"
		"\n"
		"::\n"
		"\n"
		"  taylor(DM ex, DM x, DM a, int order) -> DM\n"
		"  taylor(SX ex, SX x, SX a, int order) -> SX\n"
		"\n"
		"\n"
		"Calculate the Taylor expansion of expression 'ex' up to order 'order' \n"
		"with \n"
		"respect to variable 'x' around the point 'a'\n"
		"\n"
		"$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac \n"
		"\n"
		"{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$\n"
		"\n"
		"Example usage:\n"
		"\n"
		"::\n"
		"\n"
		">>> taylor(sin(x), x)\n"
		"\n"
		"::\n"
		"\n"
		">>   x\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L758\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L758-L760\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"mtaylor", _wrap_mtaylor, METH_VARARGS, (char *)"\n"
		"  multivariate Taylor series expansion\n"
		"\n"
		"::\n"
		"\n"
		"  mtaylor(DM ex, DM x, DM a, int order) -> DM\n"
		"  mtaylor(SX ex, SX x, SX a, int order) -> SX\n"
		"  mtaylor(DM ex, DM x, DM a, int order, [int] order_contributions) -> DM\n"
		"  mtaylor(SX ex, SX x, SX a, int order, [int] order_contributions) -> SX\n"
		"\n"
		"\n"
		"Do Taylor expansions until the aggregated order of a term is equal to \n"
		"\n"
		"'order'. The aggregated order of  $x^n y^m$ equals  $n+m$.\n"
		"\n"
		"The argument order_contributions can denote how match each variable \n"
		"\n"
		"contributes to the aggregated order. If x=[x, y] and \n"
		"\n"
		"order_contributions=[1, 2], then the aggregated order of  $x^n y^m$ equals  \n"
		"$1n+2m$.\n"
		"\n"
		"Example usage\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		">>> taylor(sin(x+y),[x, y],[a, b], 1)\n"
		" $ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $\n"
		"\n"
		"::\n"
		"\n"
		">>> taylor(sin(x+y),[x, y],[0, 0], 4)\n"
		" $ y+x-(x^3+3y x^2+3 y^2 x+y^3)/6 $\n"
		"\n"
		"::\n"
		"\n"
		">>> taylor(sin(x+y),[x, y],[0, 0], 4,[1, 2])\n"
		" $ (-3 x^2 y-x^3)/6+y+x $\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23s\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L801\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L801-L805\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"poly_coeff", _wrap_poly_coeff, METH_VARARGS, (char *)"\n"
		"  extracts polynomial coefficients from an expression\n"
		"\n"
		"::\n"
		"\n"
		"  poly_coeff(DM ex, DM x) -> DM\n"
		"  poly_coeff(SX ex, SX x) -> SX\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"ex: \n"
		"Scalar expression that represents a polynomial\n"
		"\n"
		"x: \n"
		"Scalar symbol that the polynomial is build up with\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_197\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L813\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L813-L816\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"poly_roots", _wrap_poly_roots, METH_VARARGS, (char *)"\n"
		"  Attempts to find the roots of a polynomial.\n"
		"\n"
		"::\n"
		"\n"
		"  poly_roots(DM p) -> DM\n"
		"  poly_roots(SX p) -> SX\n"
		"\n"
		"\n"
		"This will only work for polynomials up to order 3 It is assumed that \n"
		"the \n"
		"roots are real.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_198\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L824\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L824-L826\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"eig_symbolic", _wrap_eig_symbolic, METH_VARARGS, (char *)"\n"
		"  Attempts to find the eigenvalues of a symbolic matrix.\n"
		"\n"
		"::\n"
		"\n"
		"  eig_symbolic(DM m) -> DM\n"
		"  eig_symbolic(SX m) -> SX\n"
		"\n"
		"\n"
		"This will only work for up to 3x3 matrices\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_199\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L833\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/matrix_decl.hpp#L833-L835\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"find", (PyCFunction)_wrap_find, METH_O, (char *)"\n"
		"  find nonzeros\n"
		"\n"
		"::\n"
		"\n"
		"  find(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1le\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L559\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/casadi_misc.hpp#L559-L565\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"low", _wrap_low, METH_VARARGS, (char *)"\n"
		"  Find first nonzero.\n"
		"\n"
		"::\n"
		"\n"
		"  low(MX v, MX p, dict options) -> MX\n"
		"\n"
		"\n"
		"If failed, returns the number of rows\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_r8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L699\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L699-L701\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"inv_node", (PyCFunction)_wrap_inv_node, METH_O, (char *)"\n"
		"  Inverse node.\n"
		"\n"
		"::\n"
		"\n"
		"  inv_node(MX x) -> MX\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_re\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L793\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L793-L795\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"matrix_expand", _wrap_matrix_expand, METH_VARARGS, (char *)"\n"
		"  Expand  MX graph to SXFunction call.\n"
		"\n"
		"::\n"
		"\n"
		"  matrix_expand(MX e, [MX] boundary, dict options) -> MX\n"
		"  matrix_expand([MX] e, [MX] boundary, dict options) -> [MX]\n"
		"\n"
		"\n"
		"Expand the given expression e, optionally supplying expressions \n"
		"contained \n"
		"in it at which expansion should stop.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_rc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L745\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L745-L749\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"graph_substitute", _wrap_graph_substitute, METH_VARARGS, (char *)"\n"
		"  Substitute multiple expressions in graph.\n"
		"\n"
		"::\n"
		"\n"
		"  graph_substitute(MX ex, [MX] v, [MX] vdef) -> MX\n"
		"  graph_substitute([MX] ex, [MX] v, [MX] vdef) -> [MX]\n"
		"\n"
		"\n"
		"Substitute variable var with expression expr in multiple expressions, \n"
		"\n"
		"preserving nodes\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ra\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L720\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L720-L724\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"bspline", _wrap_bspline, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  bspline(MX x, DM coeffs, [[float]] knots, [int] degree, int m, dict opts) -> MX\n"
		"  bspline(MX x, MX coeffs, [[float]] knots, [int] degree, int m, dict opts) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"convexify", _wrap_convexify, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  convexify(MX H, dict opts) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"stop_diff", _wrap_stop_diff, METH_VARARGS, (char *)"\n"
		"  Stop derivatives of an expression wrt to a select set of symbolic \n"
		"\n"
		"::\n"
		"\n"
		"  stop_diff(MX expr, int order) -> MX\n"
		"  stop_diff(MX expr, MX var, int order) -> MX\n"
		"\n"
		"\n"
		"variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L835\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L835-L837\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"no_hess", (PyCFunction)_wrap_no_hess, METH_O, (char *)"\n"
		"  Stop second derivatives of an expression wrt to all its symbolic \n"
		"\n"
		"::\n"
		"\n"
		"  no_hess(MX expr) -> MX\n"
		"\n"
		"variables.\n"
		"\n"
		"\\\\seealso stop_diff\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25n\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L827\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L827-L829\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"no_grad", (PyCFunction)_wrap_no_grad, METH_O, (char *)"\n"
		"  Stop first derivatives of an expression wrt to all its symbolic \n"
		"\n"
		"::\n"
		"\n"
		"  no_grad(MX expr) -> MX\n"
		"\n"
		"variables.\n"
		"\n"
		"\\\\seealso stop_diff\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_25m\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L818\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/mx.hpp#L818-L820\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_type_name", (PyCFunction)_wrap_Importer_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_test_cast", (PyCFunction)_wrap_Importer_test_cast, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  test_cast(casadi::SharedObjectInternal const * ptr) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_has_plugin", (PyCFunction)_wrap_Importer_has_plugin, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  has_plugin(str name) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_load_plugin", (PyCFunction)_wrap_Importer_load_plugin, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  load_plugin(str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_doc", (PyCFunction)_wrap_Importer_doc, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  doc(str name) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_plugin_name", (PyCFunction)_wrap_Importer_plugin_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  plugin_name(self) -> str\n"
		"\n"
		"Query plugin name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L118\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L71-L73\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_has_function", _wrap_Importer_has_function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_function(self, str symname) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_has_meta", _wrap_Importer_has_meta, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_meta(self, str cmd, int ind) -> bool\n"
		"\n"
		"Does a meta entry exist?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_165\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L145\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L83-L85\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_get_meta", _wrap_Importer_get_meta, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_meta(self, str cmd, int ind) -> str\n"
		"\n"
		"Get entry as a text.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_166\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L150\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L87-L89\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_inlined", _wrap_Importer_inlined, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  inlined(self, str symname) -> bool\n"
		"\n"
		"Check if a function is inlined.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L153\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L91-L93\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_body", _wrap_Importer_body, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  body(self, str symname) -> str\n"
		"\n"
		"Get the function body, if inlined.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L156\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L95-L97\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_library", (PyCFunction)_wrap_Importer_library, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  library(self) -> str\n"
		"\n"
		"Get library name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L159\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L99-L101\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_serialize", _wrap_Importer_serialize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  serialize(self, casadi::SerializingStream & s)\n"
		"\n"
		"Serialize an object.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_16c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L211\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L103-L105\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_deserialize", (PyCFunction)_wrap_Importer_deserialize, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  deserialize(casadi::DeserializingStream & s) -> Importer\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Importer", _wrap_new_Importer, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Importer()\n"
		"  Importer(Importer other)\n"
		"  Importer(str name, str compiler, dict opts)\n"
		"\n"
		" Importer factory.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L97\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L34-L45\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Importer(Importer other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Importer()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L94\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L31-L32\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Importer(str name, str compiler, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		" Importer factory.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.hpp#L97\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/importer.cpp#L34-L45\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Importer", (PyCFunction)_wrap_delete_Importer, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  Importer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Importer_swigregister", Importer_swigregister, METH_VARARGS, NULL},
	 { (char *)"Callback_type_name", (PyCFunction)_wrap_Callback_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Callback", _wrap_new_Callback, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Callback(self)\n"
		"  Callback(self, Callback obj)\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L59\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L29-L30\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Callback(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o2\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L59\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L29-L30\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Callback(self, Callback obj)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Copy constructor (throws an error)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o3\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L64\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L32-L34\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Callback", (PyCFunction)_wrap_delete_Callback, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Callback(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o4\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L69\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L44-L51\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_construct", _wrap_Callback_construct, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  construct(self, str name, dict opts)\n"
		"\n"
		"Construct internal object.\n"
		"\n"
		"This is the step that actually construct the internal object, as the \n"
		"class \n"
		"constructor only creates a null pointer. It should be called \n"
		"from the user \n"
		"constructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o5\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L78\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L36-L42\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_init", (PyCFunction)_wrap_Callback_init, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  init(self)\n"
		"\n"
		"Initialize the object.\n"
		"\n"
		"This function is called after the object construction (for the whole \n"
		"class \n"
		"hierarchy) is complete, but before the finalization step. It is \n"
		"called \n"
		"recursively for the whole class hierarchy, starting with the \n"
		"lowest level.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o6\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L88\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L88-L88\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_finalize", (PyCFunction)_wrap_Callback_finalize, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  finalize(self)\n"
		"\n"
		"Finalize the object.\n"
		"\n"
		"This function is called after the construction and init steps are \n"
		"\n"
		"completed, but before user functions are called. It is called \n"
		"recursively \n"
		"for the whole class hierarchy, starting with the highest \n"
		"level.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o7\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L98\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L98-L98\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_eval", _wrap_Callback_eval, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  eval(self, [DM] arg) -> [DM]\n"
		"\n"
		"Evaluate numerically, using temporary matrices and work vectors.\n"
		"\n"
		"This signature is not thread-safe. For guaranteed thread-safety, use  \n"
		"eval_buffer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o8\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L106\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L60-L62\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_eval_buffer", _wrap_Callback_eval_buffer, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  eval_buffer(self, double const ** arg, [int] sizes_arg, double ** res, [int] sizes_res) -> int\n"
		"\n"
		"A copy-free low level interface.\n"
		"\n"
		"In Python, you will be passed two tuples of memoryview objects Note \n"
		"that \n"
		"only the structural nonzeros are present in the memoryview \n"
		"objects/buffers.\n"
		"\n"
		"Make sure to override  has_eval_buffer() to indicate support for this \n"
		"method.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_o9\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L116\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L53-L56\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_has_eval_buffer", (PyCFunction)_wrap_Callback_has_eval_buffer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_eval_buffer(self) -> bool\n"
		"\n"
		"Does the  Callback class support a copy-free low level interface\n"
		" ?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_265\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L122\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L57-L59\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_n_in", (PyCFunction)_wrap_Callback_get_n_in, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_n_in(self) -> int\n"
		"\n"
		"Get the number of inputs.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oa\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L129\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L64-L66\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_n_out", (PyCFunction)_wrap_Callback_get_n_out, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_n_out(self) -> int\n"
		"\n"
		"Get the number of outputs.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ob\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L136\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L68-L70\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_sparsity_in", _wrap_Callback_get_sparsity_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_sparsity_in(self, int i) -> Sparsity\n"
		"\n"
		"Get the sparsity of an input.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oc\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L143\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L72-L74\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_sparsity_out", _wrap_Callback_get_sparsity_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_sparsity_out(self, int i) -> Sparsity\n"
		"\n"
		"Get the sparsity of an output.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_od\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L150\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L76-L78\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_name_in", _wrap_Callback_get_name_in, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_name_in(self, int i) -> str\n"
		"\n"
		"Get the name of an input.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oe\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L157\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L80-L82\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_name_out", _wrap_Callback_get_name_out, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_name_out(self, int i) -> str\n"
		"\n"
		"Get the name of an output.\n"
		"\n"
		"This function is called during construction.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_of\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L164\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L84-L86\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_uses_output", (PyCFunction)_wrap_Callback_uses_output, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  uses_output(self) -> bool\n"
		"\n"
		"Do the derivative functions need nondifferentiated outputs?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_og\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L169\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L88-L90\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_has_jacobian", (PyCFunction)_wrap_Callback_has_jacobian, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_jacobian(self) -> bool\n"
		"\n"
		"Return Jacobian of all input elements with respect to all output\n"
		"\n"
		"elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L175\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L92-L94\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_jacobian", _wrap_Callback_get_jacobian, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_jacobian(self, str name, [str] inames, [str] onames, dict opts) -> Function\n"
		"\n"
		"Return Jacobian of all input elements with respect to all output\n"
		"\n"
		"elements.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oh\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L176\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L97-L102\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_has_forward", _wrap_Callback_has_forward, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_forward(self, int nfwd) -> bool\n"
		"\n"
		"Return function that calculates forward derivatives.\n"
		"\n"
		"forward(nfwd) returns a cached instance if available, and calls   Function \n"
		"get_forward(casadi_int nfwd) if no cached version is available.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L190\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L112-L114\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_forward", _wrap_Callback_get_forward, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_forward(self, int nfwd, str name, [str] inames, [str] onames, dict opts) -> Function\n"
		"\n"
		"Return function that calculates forward derivatives.\n"
		"\n"
		"forward(nfwd) returns a cached instance if available, and calls   Function \n"
		"get_forward(casadi_int nfwd) if no cached version is available.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oi\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L191\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L105-L110\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_has_reverse", _wrap_Callback_has_reverse, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_reverse(self, int nadj) -> bool\n"
		"\n"
		"Return function that calculates adjoint derivatives.\n"
		"\n"
		"reverse(nadj) returns a cached instance if available, and calls   Function \n"
		"get_reverse(casadi_int nadj) if no cached version is available.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L205\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L124-L126\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_reverse", _wrap_Callback_get_reverse, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_reverse(self, int nadj, str name, [str] inames, [str] onames, dict opts) -> Function\n"
		"\n"
		"Return function that calculates adjoint derivatives.\n"
		"\n"
		"reverse(nadj) returns a cached instance if available, and calls   Function \n"
		"get_reverse(casadi_int nadj) if no cached version is available.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_oj\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L206\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.cpp#L117-L122\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_has_jac_sparsity", _wrap_Callback_has_jac_sparsity, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_jac_sparsity(self, int oind, int iind) -> bool\n"
		"\n"
		"Return sparsity of Jacobian of all input elements.\n"
		"\n"
		"with respect to all output elements\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ok\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L218\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L218-L218\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Callback_get_jac_sparsity", _wrap_Callback_get_jac_sparsity, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_jac_sparsity(self, int oind, int iind, bool symmetric) -> Sparsity\n"
		"\n"
		"Return sparsity of Jacobian of all input elements.\n"
		"\n"
		"with respect to all output elements\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_ok\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L219\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/callback.hpp#L219-L220\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"disown_Callback", (PyCFunction)_wrap_disown_Callback, METH_O, NULL},
	 { (char *)"Callback_swigregister", Callback_swigregister, METH_VARARGS, NULL},
	 { (char *)"GlobalOptions_setSimplificationOnTheFly", (PyCFunction)_wrap_GlobalOptions_setSimplificationOnTheFly, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  setSimplificationOnTheFly(bool flag)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_getSimplificationOnTheFly", (PyCFunction)_wrap_GlobalOptions_getSimplificationOnTheFly, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  getSimplificationOnTheFly() -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_setHierarchicalSparsity", (PyCFunction)_wrap_GlobalOptions_setHierarchicalSparsity, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  setHierarchicalSparsity(bool flag)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_getHierarchicalSparsity", (PyCFunction)_wrap_GlobalOptions_getHierarchicalSparsity, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  getHierarchicalSparsity() -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_setCasadiPath", (PyCFunction)_wrap_GlobalOptions_setCasadiPath, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  setCasadiPath(str path)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_getCasadiPath", (PyCFunction)_wrap_GlobalOptions_getCasadiPath, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  getCasadiPath() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_setCasadiIncludePath", (PyCFunction)_wrap_GlobalOptions_setCasadiIncludePath, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  setCasadiIncludePath(str path)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_getCasadiIncludePath", (PyCFunction)_wrap_GlobalOptions_getCasadiIncludePath, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  getCasadiIncludePath() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_setMaxNumDir", (PyCFunction)_wrap_GlobalOptions_setMaxNumDir, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  setMaxNumDir(int ndir)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_getMaxNumDir", (PyCFunction)_wrap_GlobalOptions_getMaxNumDir, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  getMaxNumDir() -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_GlobalOptions", (PyCFunction)_wrap_new_GlobalOptions, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GlobalOptions(GlobalOptions other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_GlobalOptions", (PyCFunction)_wrap_delete_GlobalOptions, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  GlobalOptions(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"GlobalOptions_swigregister", GlobalOptions_swigregister, METH_VARARGS, NULL},
	 { (char *)"CasadiMeta_version", (PyCFunction)_wrap_CasadiMeta_version, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  version() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_git_revision", (PyCFunction)_wrap_CasadiMeta_git_revision, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  git_revision() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_git_describe", (PyCFunction)_wrap_CasadiMeta_git_describe, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  git_describe() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_feature_list", (PyCFunction)_wrap_CasadiMeta_feature_list, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  feature_list() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_build_type", (PyCFunction)_wrap_CasadiMeta_build_type, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  build_type() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_compiler_id", (PyCFunction)_wrap_CasadiMeta_compiler_id, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  compiler_id() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_compiler", (PyCFunction)_wrap_CasadiMeta_compiler, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  compiler() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_compiler_flags", (PyCFunction)_wrap_CasadiMeta_compiler_flags, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  compiler_flags() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_modules", (PyCFunction)_wrap_CasadiMeta_modules, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  modules() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_plugins", (PyCFunction)_wrap_CasadiMeta_plugins, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  plugins() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_install_prefix", (PyCFunction)_wrap_CasadiMeta_install_prefix, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  install_prefix() -> char const *\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_CasadiMeta", (PyCFunction)_wrap_new_CasadiMeta, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  CasadiMeta(CasadiMeta other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_CasadiMeta", (PyCFunction)_wrap_delete_CasadiMeta, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  CasadiMeta(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"CasadiMeta_swigregister", CasadiMeta_swigregister, METH_VARARGS, NULL},
	 { (char *)"collocation_points", _wrap_collocation_points, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  collocation_points(int order, str scheme) -> [float]\n"
		"\n"
		"Obtain collocation points of specific order and scheme.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"order: \n"
		"Which order (1 to 9 supported)\n"
		"\n"
		"scheme: \n"
		"'radau' or 'legendre'\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1so\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L120\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L120-L122\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"collocation_interpolators", (PyCFunction)_wrap_collocation_interpolators, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  collocation_interpolators([float] tau) -> ([[float]] OUTPUT, [float] OUTPUT)\n"
		"\n"
		"Obtain collocation interpolating matrices.\n"
		"\n"
		"A collocation method poses a polynomial Pi that interpolates exactly \n"
		"\n"
		"through an initial state (0,X_0) and helper states at collocation \n"
		"points \n"
		"(tau_j,X:collPoint(j)).\n"
		"\n"
		"This function computes the linear mapping between dPi/dt and \n"
		"coefficients \n"
		"Z=[X_0 X:collPoints].\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"tau: \n"
		"location of collocation points, as obtained from collocation_points\n"
		"\n"
		"C: \n"
		"interpolating coefficients to obtain derivatives. Length: order+1, \n"
		"\n"
		"order+1\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"dPi/dt @Z_j = (1/h) Sum_i C[j][i]*Z_i,\n"
		"\n"
		"\n"
		"\n"
		"with h the length of the integration interval.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"D: \n"
		"interpolating coefficients to obtain end state. Length: order+1\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"Pi @X_f = Sum_i D[i]*Z_i\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sp\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L189-L231\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"collocation_coeff", (PyCFunction)_wrap_collocation_coeff, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  collocation_coeff([float] tau) -> (DM OUTPUT, DM OUTPUT, DM OUTPUT)\n"
		"\n"
		"Obtain collocation interpolating matrices.\n"
		"\n"
		"A collocation method poses a polynomial Pi that interpolates exactly \n"
		"\n"
		"through an initial state (0,X_0) and helper states at collocation \n"
		"points \n"
		"(tau_j,Xc_j) with j=1..degree.\n"
		"\n"
		"This function computes the linear mapping between dPi/dt and \n"
		"coefficients \n"
		"Z=[X_0 Xc].\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"tau: \n"
		"location of collocation points (length: degree), as obtained from \n"
		"\n"
		"collocation_points\n"
		"\n"
		"C: \n"
		"interpolating coefficients to obtain derivatives. Size: (degree+1)-by-\n"
		"\n"
		"degree\n"
		"\n"
		"You may find the slopes of Pi at the collocation points as\n"
		"\n"
		"::\n"
		"\n"
		"dPi/dt @ Xc = (1/h) Z*C,\n"
		"\n"
		"\n"
		"\n"
		"with h the length of the integration interval.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"D: \n"
		"interpolating coefficients to obtain end state. Size: (degree+1)-by-1\n"
		"\n"
		"You may find the end point of Pi as\n"
		"\n"
		"::\n"
		"\n"
		"Pi @X_f = Z*D\n"
		"\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"B: \n"
		"quadrature coefficients Size: degree-by-1\n"
		"\n"
		"Given quadrature righ-hand-sides 'quad' evaluated at the collocation \n"
		"\n"
		"points, you may find the integrated quadratures as\n"
		"\n"
		"::\n"
		"\n"
		"q = quad*B*h\n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sq\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L233\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L233-L287\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"simpleRK", _wrap_simpleRK, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  simpleRK(Function f, int N, int order) -> Function\n"
		"\n"
		"Construct an explicit Runge-Kutta integrator.\n"
		"\n"
		"The constructed function has three inputs, corresponding to initial \n"
		"state \n"
		"(x0), parameter (p) and integration time (h) and one output, \n"
		"corresponding \n"
		"to final state (xf).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"f: \n"
		"ODE function with two inputs (x and p) and one output (xdot)\n"
		"\n"
		"N: \n"
		"Number of integrator steps\n"
		"\n"
		"order: \n"
		"Order of interpolating polynomials\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sr\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L128\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L128-L187\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"simpleIRK", _wrap_simpleIRK, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  simpleIRK(Function f, int N, int order, str scheme, str solver, dict solver_options) -> Function\n"
		"\n"
		"Construct an implicit Runge-Kutta integrator using a collocation\n"
		"\n"
		"scheme.\n"
		"\n"
		"The constructed function has three inputs, corresponding to initial \n"
		"state \n"
		"(x0), parameter (p) and integration time (h) and one output, \n"
		"corresponding \n"
		"to final state (xf).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"f: \n"
		"ODE function with two inputs (x and p) and one output (xdot)\n"
		"\n"
		"N: \n"
		"Number of integrator steps\n"
		"\n"
		"order: \n"
		"Order of interpolating polynomials\n"
		"\n"
		"scheme: \n"
		" Collocation scheme, as excepted by collocationPoints function.\n"
		"\n"
		"solver: \n"
		"Solver plugin\n"
		"\n"
		"solver_options: \n"
		"Options to be passed to the solver plugin\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1ss\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L289\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L289-L354\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"simpleIntegrator", _wrap_simpleIntegrator, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  simpleIntegrator(Function f, str integrator, dict integrator_options) -> Function\n"
		"\n"
		"Simplified wrapper for the  Integrator class.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1st\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L356\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L356-L395\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dae_reduce_index", _wrap_dae_reduce_index, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dae_reduce_index(dict:SX dae, dict opts) -> (dict:SX , dict OUTPUT)\n"
		"  dae_reduce_index(dict:MX dae, dict opts) -> (dict:MX , dict OUTPUT)\n"
		"\n"
		"Reduce index.\n"
		"\n"
		"Index reduction leads to a new set of variables and equations.\n"
		"\n"
		"In the process, a set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"a.k.a invariants is constructed that are invariant to the\n"
		" problem: whenever\n"
		" an initial point satisfies these constraints, the \n"
		"boundary-value-problem \n"
		"outcome will keep satisfying those constraints \n"
		"automatically, even though \n"
		"they are  not part of the reduced DAE.\n"
		"\n"
		"For any practical numerical integration method, there will be \n"
		"numerical \n"
		"drift away from satisfaction of those constraints. In other \n"
		"words, you will\n"
		" see the value of invariants slowly moving away from \n"
		"original zero.\n"
		"\n"
		"A classic mitigation technique is Baumgarte stabilization: you add \n"
		"these \n"
		"invariants to the reduced DAE as a correction term that acts in \n"
		"a way to \n"
		"make small (numerical) perturbations to the invariants decay \n"
		"to the origin \n"
		"as a dampened linear system.\n"
		"\n"
		"in which a certain set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"has been dropped in favour of\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Expression dictionary describing the DAE\n"
		"\n"
		"Each value must be a dense column vector.\n"
		"\n"
		"keys:\n"
		"x_impl: symbol for implicit differential states\n"
		"\n"
		"dx_impl: symbol for implicit differential state derivatives\n"
		"\n"
		"z: symbol for algebraic variables\n"
		"\n"
		"alg: expression for algebraic equations\n"
		"\n"
		"t: symbol for time\n"
		"\n"
		"p: symbol for parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"opts: \n"
		"Option dictionary\n"
		"\n"
		"'baumgarte_pole': double Poles (inverse time constants) of the \n"
		"Baumgarte \n"
		"invariant correction term. Must be <0 to dampen out \n"
		"perturbations 0 \n"
		"(default) amounts to no correction. Corresponds to \n"
		"-gamma of equation (1.5)\n"
		" in Ascher, Uri M., Hongsheng Chin, and \n"
		"Sebastian Reich. \"Stabilization of\n"
		" DAEs and invariant manifolds.\" \n"
		"Numerische Mathematik 67.2 (1994): \n"
		"131-149.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stats: \n"
		"Statistics\n"
		"\n"
		"Expression dictionary describing the reduced DAE\n"
		"\n"
		"In addition the fields allowed in the input DAE, the following keys \n"
		"occur:\n"
		"\n"
		"x: symbol for explicit differential states\n"
		"\n"
		"ode: expression for right-hand-side of explicit differential states\n"
		"\n"
		"I: expression for invariants\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1056\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1056-L1058\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_reduce_index(dict:SX dae, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Reduce index.\n"
		"\n"
		"Index reduction leads to a new set of variables and equations.\n"
		"\n"
		"In the process, a set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"a.k.a invariants is constructed that are invariant to the\n"
		" problem: whenever\n"
		" an initial point satisfies these constraints, the \n"
		"boundary-value-problem \n"
		"outcome will keep satisfying those constraints \n"
		"automatically, even though \n"
		"they are  not part of the reduced DAE.\n"
		"\n"
		"For any practical numerical integration method, there will be \n"
		"numerical \n"
		"drift away from satisfaction of those constraints. In other \n"
		"words, you will\n"
		" see the value of invariants slowly moving away from \n"
		"original zero.\n"
		"\n"
		"A classic mitigation technique is Baumgarte stabilization: you add \n"
		"these \n"
		"invariants to the reduced DAE as a correction term that acts in \n"
		"a way to \n"
		"make small (numerical) perturbations to the invariants decay \n"
		"to the origin \n"
		"as a dampened linear system.\n"
		"\n"
		"in which a certain set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"has been dropped in favour of\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Expression dictionary describing the DAE\n"
		"\n"
		"Each value must be a dense column vector.\n"
		"\n"
		"keys:\n"
		"x_impl: symbol for implicit differential states\n"
		"\n"
		"dx_impl: symbol for implicit differential state derivatives\n"
		"\n"
		"z: symbol for algebraic variables\n"
		"\n"
		"alg: expression for algebraic equations\n"
		"\n"
		"t: symbol for time\n"
		"\n"
		"p: symbol for parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"opts: \n"
		"Option dictionary\n"
		"\n"
		"'baumgarte_pole': double Poles (inverse time constants) of the \n"
		"Baumgarte \n"
		"invariant correction term. Must be <0 to dampen out \n"
		"perturbations 0 \n"
		"(default) amounts to no correction. Corresponds to \n"
		"-gamma of equation (1.5)\n"
		" in Ascher, Uri M., Hongsheng Chin, and \n"
		"Sebastian Reich. \"Stabilization of\n"
		" DAEs and invariant manifolds.\" \n"
		"Numerische Mathematik 67.2 (1994): \n"
		"131-149.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stats: \n"
		"Statistics\n"
		"\n"
		"Expression dictionary describing the reduced DAE\n"
		"\n"
		"In addition the fields allowed in the input DAE, the following keys \n"
		"occur:\n"
		"\n"
		"x: symbol for explicit differential states\n"
		"\n"
		"ode: expression for right-hand-side of explicit differential states\n"
		"\n"
		"I: expression for invariants\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1060\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1060-L1062\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_reduce_index(dict:MX dae, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Reduce index.\n"
		"\n"
		"Index reduction leads to a new set of variables and equations.\n"
		"\n"
		"In the process, a set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"a.k.a invariants is constructed that are invariant to the\n"
		" problem: whenever\n"
		" an initial point satisfies these constraints, the \n"
		"boundary-value-problem \n"
		"outcome will keep satisfying those constraints \n"
		"automatically, even though \n"
		"they are  not part of the reduced DAE.\n"
		"\n"
		"For any practical numerical integration method, there will be \n"
		"numerical \n"
		"drift away from satisfaction of those constraints. In other \n"
		"words, you will\n"
		" see the value of invariants slowly moving away from \n"
		"original zero.\n"
		"\n"
		"A classic mitigation technique is Baumgarte stabilization: you add \n"
		"these \n"
		"invariants to the reduced DAE as a correction term that acts in \n"
		"a way to \n"
		"make small (numerical) perturbations to the invariants decay \n"
		"to the origin \n"
		"as a dampened linear system.\n"
		"\n"
		"in which a certain set of constraints (algebraic equations or \n"
		"derivatives) \n"
		"has been dropped in favour of\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Expression dictionary describing the DAE\n"
		"\n"
		"Each value must be a dense column vector.\n"
		"\n"
		"keys:\n"
		"x_impl: symbol for implicit differential states\n"
		"\n"
		"dx_impl: symbol for implicit differential state derivatives\n"
		"\n"
		"z: symbol for algebraic variables\n"
		"\n"
		"alg: expression for algebraic equations\n"
		"\n"
		"t: symbol for time\n"
		"\n"
		"p: symbol for parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"opts: \n"
		"Option dictionary\n"
		"\n"
		"'baumgarte_pole': double Poles (inverse time constants) of the \n"
		"Baumgarte \n"
		"invariant correction term. Must be <0 to dampen out \n"
		"perturbations 0 \n"
		"(default) amounts to no correction. Corresponds to \n"
		"-gamma of equation (1.5)\n"
		" in Ascher, Uri M., Hongsheng Chin, and \n"
		"Sebastian Reich. \"Stabilization of\n"
		" DAEs and invariant manifolds.\" \n"
		"Numerische Mathematik 67.2 (1994): \n"
		"131-149.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stats: \n"
		"Statistics\n"
		"\n"
		"Expression dictionary describing the reduced DAE\n"
		"\n"
		"In addition the fields allowed in the input DAE, the following keys \n"
		"occur:\n"
		"\n"
		"x: symbol for explicit differential states\n"
		"\n"
		"ode: expression for right-hand-side of explicit differential states\n"
		"\n"
		"I: expression for invariants\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_23h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1056\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1056-L1058\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dae_map_semi_expl", _wrap_dae_map_semi_expl, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dae_map_semi_expl(dict:SX dae, dict:SX dae_red) -> (dict:SX , Function OUTPUT, Function OUTPUT)\n"
		"  dae_map_semi_expl(dict:MX dae, dict:MX dae_red) -> (dict:MX , Function OUTPUT, Function OUTPUT)\n"
		"\n"
		"Turn a reduced DAE into a semi explicit form suitable for CasADi\n"
		"\n"
		"integrator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"state_to_orig: \n"
		"A mapping of integrator (semi explicit) states to states of \n"
		"the \n"
		"original DAE\n"
		"\n"
		"phi: \n"
		"A function to compute the invariants of the reduced DAE Inputs:\n"
		"x and \n"
		"z: (semi explicit) integrator states; typically integrator \n"
		"outputs xf and \n"
		"zf\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time\n"
		"\n"
		"Semi explicit DAE dictionary, suitable to pass to a CasADi integrator\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1su\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1200-L1203\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_map_semi_expl(dict:SX dae, dict:SX dae_red)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Turn a reduced DAE into a semi explicit form suitable for CasADi\n"
		"\n"
		"integrator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"state_to_orig: \n"
		"A mapping of integrator (semi explicit) states to states of \n"
		"the \n"
		"original DAE\n"
		"\n"
		"phi: \n"
		"A function to compute the invariants of the reduced DAE Inputs:\n"
		"x and \n"
		"z: (semi explicit) integrator states; typically integrator \n"
		"outputs xf and \n"
		"zf\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time\n"
		"\n"
		"Semi explicit DAE dictionary, suitable to pass to a CasADi integrator\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1su\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1205\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1205-L1208\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_map_semi_expl(dict:MX dae, dict:MX dae_red)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Turn a reduced DAE into a semi explicit form suitable for CasADi\n"
		"\n"
		"integrator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"state_to_orig: \n"
		"A mapping of integrator (semi explicit) states to states of \n"
		"the \n"
		"original DAE\n"
		"\n"
		"phi: \n"
		"A function to compute the invariants of the reduced DAE Inputs:\n"
		"x and \n"
		"z: (semi explicit) integrator states; typically integrator \n"
		"outputs xf and \n"
		"zf\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time\n"
		"\n"
		"Semi explicit DAE dictionary, suitable to pass to a CasADi integrator\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1su\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1200-L1203\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"dae_init_gen", _wrap_dae_init_gen, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dae_init_gen(dict:SX dae, dict:SX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options) -> Function\n"
		"  dae_init_gen(dict:MX dae, dict:MX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options) -> Function\n"
		"\n"
		"Obtain a generator  Function for producing consistent initial \n"
		"guesses of a reduced DAE.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"init_solver: \n"
		"NLP solver plugin name for nlpsol used to construct an initial\n"
		" guess\n"
		"\n"
		"init_strength: \n"
		"Influence the nature of the NLP Structure with keys x_impl, \n"
		"dx_impl, z\n"
		" corresponding to inputs of init_gen Each key maps to a DM that \n"
		"should\n"
		" match the variable size corresponding to that key. For each variable\n"
		"\n"
		"the meaning of the corresponding DM value is as follows: When >=0, \n"
		"\n"
		"indicates that the provided initial guess is used in a quadratic \n"
		"penalty \n"
		"(value used as weight) When -1, indicates that the provided \n"
		"initial guess \n"
		"must be observed (simple bound on variable)\n"
		"\n"
		"init_solver_options: \n"
		"NLP solver options to be passed to nlpsol\n"
		"\n"
		"init_gen A function to generate a consistent initial guess that can be\n"
		" used\n"
		" to pass to an integrator constructed from a semi explict reduced\n"
		" DAE \n"
		"Inputs:\n"
		"x_impl, dx_impl, z: initial guesses in the original DAE space\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time Outputs:\n"
		"\n"
		"x0, z0: (semi explicit) integrator states and algebraic variables; \n"
		"\n"
		"typically used as input for integrators\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1210\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1210-L1213\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_init_gen(dict:SX dae, dict:SX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain a generator  Function for producing consistent initial \n"
		"guesses of a reduced DAE.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"init_solver: \n"
		"NLP solver plugin name for nlpsol used to construct an initial\n"
		" guess\n"
		"\n"
		"init_strength: \n"
		"Influence the nature of the NLP Structure with keys x_impl, \n"
		"dx_impl, z\n"
		" corresponding to inputs of init_gen Each key maps to a DM that \n"
		"should\n"
		" match the variable size corresponding to that key. For each variable\n"
		"\n"
		"the meaning of the corresponding DM value is as follows: When >=0, \n"
		"\n"
		"indicates that the provided initial guess is used in a quadratic \n"
		"penalty \n"
		"(value used as weight) When -1, indicates that the provided \n"
		"initial guess \n"
		"must be observed (simple bound on variable)\n"
		"\n"
		"init_solver_options: \n"
		"NLP solver options to be passed to nlpsol\n"
		"\n"
		"init_gen A function to generate a consistent initial guess that can be\n"
		" used\n"
		" to pass to an integrator constructed from a semi explict reduced\n"
		" DAE \n"
		"Inputs:\n"
		"x_impl, dx_impl, z: initial guesses in the original DAE space\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time Outputs:\n"
		"\n"
		"x0, z0: (semi explicit) integrator states and algebraic variables; \n"
		"\n"
		"typically used as input for integrators\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1215\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1215-L1218\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  dae_init_gen(dict:MX dae, dict:MX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain a generator  Function for producing consistent initial \n"
		"guesses of a reduced DAE.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"dae: \n"
		"Original (unreduced) DAE structure\n"
		"\n"
		"dae_red: \n"
		"Reduced DAE (see dae_reduce_index)\n"
		"\n"
		"init_solver: \n"
		"NLP solver plugin name for nlpsol used to construct an initial\n"
		" guess\n"
		"\n"
		"init_strength: \n"
		"Influence the nature of the NLP Structure with keys x_impl, \n"
		"dx_impl, z\n"
		" corresponding to inputs of init_gen Each key maps to a DM that \n"
		"should\n"
		" match the variable size corresponding to that key. For each variable\n"
		"\n"
		"the meaning of the corresponding DM value is as follows: When >=0, \n"
		"\n"
		"indicates that the provided initial guess is used in a quadratic \n"
		"penalty \n"
		"(value used as weight) When -1, indicates that the provided \n"
		"initial guess \n"
		"must be observed (simple bound on variable)\n"
		"\n"
		"init_solver_options: \n"
		"NLP solver options to be passed to nlpsol\n"
		"\n"
		"init_gen A function to generate a consistent initial guess that can be\n"
		" used\n"
		" to pass to an integrator constructed from a semi explict reduced\n"
		" DAE \n"
		"Inputs:\n"
		"x_impl, dx_impl, z: initial guesses in the original DAE space\n"
		"\n"
		"p: parameters\n"
		"\n"
		"t: time Outputs:\n"
		"\n"
		"x0, z0: (semi explicit) integrator states and algebraic variables; \n"
		"\n"
		"typically used as input for integrators\n"
		"\n"
		"See: \n"
		" dae_reduce_index\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sv\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.hpp#L1210\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/integration_tools.cpp#L1210-L1213\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"detect_simple_bounds", _wrap_detect_simple_bounds, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  detect_simple_bounds(SX xX, SX p, SX g, SX lbg, SX ubg) -> ([int] OUTPUT, SX OUTPUT, SX OUTPUT, Function OUTPUT, Function OUTPUT)\n"
		"  detect_simple_bounds(MX xX, MX p, MX g, MX lbg, MX ubg) -> ([int] OUTPUT, MX OUTPUT, MX OUTPUT, Function OUTPUT, Function OUTPUT)\n"
		"\n"
		"Detect simple bounds from general constraints.\n"
		"\n"
		"Given parametric constraints:\n"
		"\n"
		"::\n"
		"\n"
		"  *   subject to lbg(p) <= g(x,p) <= ubg(p)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Returns an equivalent set\n"
		"\n"
		"::\n"
		"\n"
		"  *   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)\n"
		"  *               lbx(p) <= x                 <= ubx(p)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lam_forward: \n"
		"(lam_g,p)->(lam_sg,lam_x)\n"
		"\n"
		"lam_backward: \n"
		"(lam_sg,lam_x,p)->(lam_g)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_tools.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_tools.cpp#L207-L215\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  detect_simple_bounds(SX xX, SX p, SX g, SX lbg, SX ubg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Detect simple bounds from general constraints.\n"
		"\n"
		"Given parametric constraints:\n"
		"\n"
		"::\n"
		"\n"
		"  *   subject to lbg(p) <= g(x,p) <= ubg(p)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Returns an equivalent set\n"
		"\n"
		"::\n"
		"\n"
		"  *   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)\n"
		"  *               lbx(p) <= x                 <= ubx(p)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lam_forward: \n"
		"(lam_g,p)->(lam_sg,lam_x)\n"
		"\n"
		"lam_backward: \n"
		"(lam_sg,lam_x,p)->(lam_g)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1sw\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_tools.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_tools.cpp#L207-L215\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  detect_simple_bounds(MX xX, MX p, MX g, MX lbg, MX ubg)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"external_transform", _wrap_external_transform, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  external_transform(str name, str op, Function f, dict opts) -> Function\n"
		"\n"
		"Apply a transformation defined externally.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of the shared library\n"
		"\n"
		"op: \n"
		"Name of the operation\n"
		"\n"
		"f: \n"
		" Function to transform\n"
		"\n"
		"opts: \n"
		"Options\n"
		"\n"
		"::\n"
		"\n"
		"  Extra doc: https://github.com/casadi/casadi/wiki/L_27i \n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/tools.hpp#L45\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/tools.cpp#L45-L77\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_x_get", (PyCFunction)_wrap_NlpBuilder_x_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_x_get(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_f_get", (PyCFunction)_wrap_NlpBuilder_f_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_f_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_g_get", (PyCFunction)_wrap_NlpBuilder_g_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_g_get(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_x_lb_get", (PyCFunction)_wrap_NlpBuilder_x_lb_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_x_lb_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_x_ub_get", (PyCFunction)_wrap_NlpBuilder_x_ub_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_x_ub_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_g_lb_get", (PyCFunction)_wrap_NlpBuilder_g_lb_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_g_lb_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_g_ub_get", (PyCFunction)_wrap_NlpBuilder_g_ub_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_g_ub_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_x_init_get", (PyCFunction)_wrap_NlpBuilder_x_init_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_x_init_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_lambda_init_get", (PyCFunction)_wrap_NlpBuilder_lambda_init_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_lambda_init_get(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_discrete_get", (PyCFunction)_wrap_NlpBuilder_discrete_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder_discrete_get(self) -> [bool]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_import_nl", _wrap_NlpBuilder_import_nl, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  import_nl(self, str filename, dict opts)\n"
		"\n"
		"Import an .nl file.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L74\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.cpp#L32-L35\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_type_name", (PyCFunction)_wrap_NlpBuilder_type_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type_name(self) -> str\n"
		"\n"
		"Readable name of the class.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L77\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L77-L77\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_disp", _wrap_NlpBuilder_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print a description of the object.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L80\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.cpp#L37-L45\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_str", _wrap_NlpBuilder_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L83\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/nlp_builder.hpp#L83-L87\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_NlpBuilder", _wrap_new_NlpBuilder, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder()\n"
		"  NlpBuilder(NlpBuilder other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_NlpBuilder", (PyCFunction)_wrap_delete_NlpBuilder, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  NlpBuilder(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"NlpBuilder_swigregister", NlpBuilder_swigregister, METH_VARARGS, NULL},
	 { (char *)"DaeBuilder_type_name", (PyCFunction)_wrap_DaeBuilder_type_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type_name(self) -> str\n"
		"\n"
		"Readable name of the class.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L74\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L74-L74\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_name", (PyCFunction)_wrap_DaeBuilder_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  name(self) -> str\n"
		"\n"
		"Name of instance.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L86\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L59-L61\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_t", (PyCFunction)_wrap_DaeBuilder_t, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  t(self) -> MX\n"
		"\n"
		"Independent variable (usually time)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L93\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L63-L65\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_x", (PyCFunction)_wrap_DaeBuilder_x, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  x(self) -> [str]\n"
		"\n"
		"Differential states.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L98\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L67-L69\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_ode", (PyCFunction)_wrap_DaeBuilder_ode, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ode(self) -> [MX]\n"
		"\n"
		"Ordinary differential equations (ODE)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L103\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L71-L73\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_z", (PyCFunction)_wrap_DaeBuilder_z, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  z(self) -> [str]\n"
		"\n"
		"Algebraic variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L108\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L75-L77\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_alg", (PyCFunction)_wrap_DaeBuilder_alg, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  alg(self) -> [MX]\n"
		"\n"
		"Algebraic equations.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5i\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L113\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L79-L81\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_q", (PyCFunction)_wrap_DaeBuilder_q, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  q(self) -> [str]\n"
		"\n"
		"Quadrature states.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L118\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L83-L85\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_quad", (PyCFunction)_wrap_DaeBuilder_quad, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  quad(self) -> [MX]\n"
		"\n"
		"Quadrature equations.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5k\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L123\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L87-L89\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_y", (PyCFunction)_wrap_DaeBuilder_y, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  y(self) -> [str]\n"
		"\n"
		" Output variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L128\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L91-L93\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_ydef", (PyCFunction)_wrap_DaeBuilder_ydef, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ydef(self) -> [MX]\n"
		"\n"
		"Definitions of output variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5m\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L133\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L95-L97\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_u", (PyCFunction)_wrap_DaeBuilder_u, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  u(self) -> [str]\n"
		"\n"
		"Free controls.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5n\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L138\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L99-L101\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_p", (PyCFunction)_wrap_DaeBuilder_p, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  p(self) -> [str]\n"
		"\n"
		"Parameters.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L143\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L103-L105\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_c", (PyCFunction)_wrap_DaeBuilder_c, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  c(self) -> [str]\n"
		"\n"
		"Named constants.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L148\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L107-L109\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_cdef", (PyCFunction)_wrap_DaeBuilder_cdef, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  cdef(self) -> [MX]\n"
		"\n"
		"Definitions of named constants.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L153\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L111-L113\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_d", (PyCFunction)_wrap_DaeBuilder_d, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  d(self) -> [str]\n"
		"\n"
		"Dependent parameters.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L158\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L115-L117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_ddef", (PyCFunction)_wrap_DaeBuilder_ddef, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ddef(self) -> [MX]\n"
		"\n"
		"Definitions of dependent parameters.\n"
		"\n"
		"Interdependencies are allowed but must be non-cyclic.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5s\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L165\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L119-L121\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_w", (PyCFunction)_wrap_DaeBuilder_w, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  w(self) -> [str]\n"
		"\n"
		"Dependent variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L170\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L123-L125\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_wdef", (PyCFunction)_wrap_DaeBuilder_wdef, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  wdef(self) -> [MX]\n"
		"\n"
		"Dependent variables and corresponding definitions.\n"
		"\n"
		"Interdependencies are allowed but must be non-cyclic.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L177\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L127-L129\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_aux", (PyCFunction)_wrap_DaeBuilder_aux, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  aux(self) -> [MX]\n"
		"\n"
		"Auxiliary variables: Used e.g. to define functions.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5v\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L182\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L131-L133\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_init_lhs", (PyCFunction)_wrap_DaeBuilder_init_lhs, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  init_lhs(self) -> [MX]\n"
		"\n"
		"Initial conditions, left-hand-side.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L187\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L135-L137\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_init_rhs", (PyCFunction)_wrap_DaeBuilder_init_rhs, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  init_rhs(self) -> [MX]\n"
		"\n"
		"Initial conditions, right-hand-side.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5x\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L192\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L139-L141\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_when_cond", (PyCFunction)_wrap_DaeBuilder_when_cond, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  when_cond(self) -> [MX]\n"
		"\n"
		"When statement: triggering condition.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5y\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L197\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L143-L145\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_when_lhs", (PyCFunction)_wrap_DaeBuilder_when_lhs, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  when_lhs(self) -> [MX]\n"
		"\n"
		"When statement: left-hand-side.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_5z\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L202\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L147-L149\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_when_rhs", (PyCFunction)_wrap_DaeBuilder_when_rhs, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  when_rhs(self) -> [MX]\n"
		"\n"
		"When statement: right-hand-side.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_60\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L207\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L151-L153\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_outputs", (PyCFunction)_wrap_DaeBuilder_outputs, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  outputs(self) -> [str]\n"
		"\n"
		"Model structure: outputs.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_61\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L213\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L155-L162\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_derivatives", (PyCFunction)_wrap_DaeBuilder_derivatives, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  derivatives(self) -> [str]\n"
		"\n"
		"Model structure: derivatives.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_62\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L218\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L164-L171\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_initial_unknowns", (PyCFunction)_wrap_DaeBuilder_initial_unknowns, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  initial_unknowns(self) -> [str]\n"
		"\n"
		"Model structure: initial unknowns.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_63\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L223\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L173-L180\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_has_t", (PyCFunction)_wrap_DaeBuilder_has_t, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_t(self) -> bool\n"
		"\n"
		"Is there a time variable?\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_64\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L231\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L182-L184\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nx", (PyCFunction)_wrap_DaeBuilder_nx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nx(self) -> int\n"
		"\n"
		"Differential states.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_65\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L236\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L186-L188\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nz", (PyCFunction)_wrap_DaeBuilder_nz, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nz(self) -> int\n"
		"\n"
		"Algebraic variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_66\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L241\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L190-L192\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nq", (PyCFunction)_wrap_DaeBuilder_nq, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nq(self) -> int\n"
		"\n"
		"Quadrature states.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_67\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L246\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L194-L196\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_ny", (PyCFunction)_wrap_DaeBuilder_ny, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  ny(self) -> int\n"
		"\n"
		" Output variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_68\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L251\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L198-L200\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nu", (PyCFunction)_wrap_DaeBuilder_nu, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nu(self) -> int\n"
		"\n"
		"Free controls.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_69\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L256\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L202-L204\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_np", (PyCFunction)_wrap_DaeBuilder_np, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  np(self) -> int\n"
		"\n"
		"Parameters.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6a\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L261\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L206-L208\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nc", (PyCFunction)_wrap_DaeBuilder_nc, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nc(self) -> int\n"
		"\n"
		"Named constants.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L266\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L210-L212\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nd", (PyCFunction)_wrap_DaeBuilder_nd, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nd(self) -> int\n"
		"\n"
		"Dependent parameters.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L271\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L214-L216\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nw", (PyCFunction)_wrap_DaeBuilder_nw, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nw(self) -> int\n"
		"\n"
		"Dependent variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L276\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L218-L220\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_t", _wrap_DaeBuilder_add_t, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_t(self, str name) -> MX\n"
		"\n"
		"Add an independent variable (time)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L284\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L430-L435\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_p", _wrap_DaeBuilder_add_p, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_p(self, str name) -> MX\n"
		"\n"
		"Add a new parameter.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L287\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L437-L444\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_u", _wrap_DaeBuilder_add_u, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_u(self, str name) -> MX\n"
		"\n"
		"Add a new control.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L290\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L446-L453\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_x", _wrap_DaeBuilder_add_x, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_x(self, str name) -> MX\n"
		"\n"
		"Add a new differential state.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L293\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L455-L462\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_z", _wrap_DaeBuilder_add_z, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_z(self, str name) -> MX\n"
		"\n"
		"Add a new algebraic variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L296\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L464-L471\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_q", _wrap_DaeBuilder_add_q, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_q(self, str name) -> MX\n"
		"\n"
		"Add a new quadrature state.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L299\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L473-L480\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_c", _wrap_DaeBuilder_add_c, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_c(self, str name, MX new_cdef) -> MX\n"
		"\n"
		"Add a new constant.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L302\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L482-L489\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_d", _wrap_DaeBuilder_add_d, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_d(self, str name, MX new_ddef) -> MX\n"
		"\n"
		"Add a new dependent parameter.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L305\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L491-L498\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_w", _wrap_DaeBuilder_add_w, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_w(self, str name, MX new_wdef) -> MX\n"
		"\n"
		"Add a new dependent variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L308\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L500-L507\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_y", _wrap_DaeBuilder_add_y, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_y(self, str name, MX new_ydef) -> MX\n"
		"\n"
		"Add a new output.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L311\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L509-L516\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_ode", _wrap_DaeBuilder_set_ode, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_ode(self, str name, MX ode_rhs)\n"
		"\n"
		"Specify the ordinary differential equation for a state.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L314\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L535-L541\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_alg", _wrap_DaeBuilder_set_alg, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_alg(self, str name, MX alg_rhs)\n"
		"\n"
		"Specificy the residual equation for an algebraic variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L317\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L543-L549\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_aux", _wrap_DaeBuilder_add_aux, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_aux(self, str name, int n) -> MX\n"
		"\n"
		"Add an auxiliary variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L320\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L518-L522\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_init", _wrap_DaeBuilder_add_init, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_init(self, MX lhs, MX rhs)\n"
		"\n"
		"Add an initial equation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L323\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L524-L527\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_when", _wrap_DaeBuilder_add_when, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_when(self, MX cond, MX lhs, MX rhs)\n"
		"\n"
		"Add a when statement.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L326\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L529-L533\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_sanity_check", (PyCFunction)_wrap_DaeBuilder_sanity_check, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sanity_check(self)\n"
		"\n"
		"Check if dimensions match.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L329\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L551-L557\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_clear_all", _wrap_DaeBuilder_clear_all, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  clear_all(self, str v)\n"
		"\n"
		"Clear all variables of a type.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L333\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L414-L420\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_all", _wrap_DaeBuilder_set_all, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_all(self, str v, [str] name)\n"
		"\n"
		"Set all variables of a type.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L336\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L422-L428\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_t", _wrap_DaeBuilder_register_t, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_t(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_p", _wrap_DaeBuilder_register_p, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_p(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_u", _wrap_DaeBuilder_register_u, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_u(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_x", _wrap_DaeBuilder_register_x, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_x(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_z", _wrap_DaeBuilder_register_z, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_z(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_q", _wrap_DaeBuilder_register_q, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_q(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_c", _wrap_DaeBuilder_register_c, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_c(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_d", _wrap_DaeBuilder_register_d, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_d(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_w", _wrap_DaeBuilder_register_w, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_w(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_register_y", _wrap_DaeBuilder_register_y, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  register_y(self, str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_u", _wrap_DaeBuilder_set_u, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_u(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_x", _wrap_DaeBuilder_set_x, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_x(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_z", _wrap_DaeBuilder_set_z, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_z(self, [str] name, [str] alg)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_q", _wrap_DaeBuilder_set_q, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_q(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_y", _wrap_DaeBuilder_set_y, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_y(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_clear_in", _wrap_DaeBuilder_clear_in, METH_VARARGS, (char *)"\n"
		"  [DEPRECATED] Clear input variable: Replaced by clear_all\n"
		"\n"
		"::\n"
		"\n"
		"  clear_in(self, str v)\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L371\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L371-L371\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_eliminate_w", (PyCFunction)_wrap_DaeBuilder_eliminate_w, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  eliminate_w(self)\n"
		"\n"
		"Eliminate all dependent variables.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L375\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L611-L617\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_lift", _wrap_DaeBuilder_lift, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  lift(self, bool lift_shared, bool lift_calls)\n"
		"\n"
		"Lift problem formulation by extracting shared subexpressions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L378\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L619-L625\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_eliminate_quad", (PyCFunction)_wrap_DaeBuilder_eliminate_quad, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  eliminate_quad(self)\n"
		"\n"
		"Eliminate quadrature states and turn them into ODE states.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L381\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L248-L254\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_sort_d", (PyCFunction)_wrap_DaeBuilder_sort_d, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sort_d(self)\n"
		"\n"
		"Sort dependent parameters.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L384\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L256-L262\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_sort_w", (PyCFunction)_wrap_DaeBuilder_sort_w, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sort_w(self)\n"
		"\n"
		"Sort dependent variables.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L387\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L264-L270\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_sort_z", _wrap_DaeBuilder_sort_z, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  sort_z(self, [str] z_order)\n"
		"\n"
		"Sort algebraic variables.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L390\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L272-L278\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_prune", _wrap_DaeBuilder_prune, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  prune(self, bool prune_p, bool prune_u)\n"
		"\n"
		"Prune unused controls.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L393\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L280-L286\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_tear", (PyCFunction)_wrap_DaeBuilder_tear, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  tear(self)\n"
		"\n"
		"Identify iteration variables and residual equations using naming\n"
		"\n"
		"convention.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L396\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L288-L294\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_fun", _wrap_DaeBuilder_add_fun, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_fun(self, Function f) -> Function\n"
		"  add_fun(self, str name, Importer compiler, dict opts) -> Function\n"
		"  add_fun(self, str name, [str] arg, [str] res, dict opts) -> Function\n"
		"\n"
		"Add an already existing function.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L410\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L751-L758\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_fun(self, Function f)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add an already existing function.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L410\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L751-L758\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_fun(self, str name, [str] arg, [str] res, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a function from loaded expressions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L405\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L760-L768\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_fun(self, str name, Importer compiler, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add an external function.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L413\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L770-L773\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_has_fun", _wrap_DaeBuilder_has_fun, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_fun(self, str name) -> bool\n"
		"\n"
		"Does a particular function already exist?\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L417\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L775-L782\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_fun", _wrap_DaeBuilder_fun, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  fun(self) -> [Function]\n"
		"  fun(self, str name) -> Function\n"
		"\n"
		"Get function by name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L420\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L784-L791\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  fun(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get function by name.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L420\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L784-L791\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  fun(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get all functions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L423\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L814-L816\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_gather_fun", _wrap_DaeBuilder_gather_fun, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  gather_fun(self, int max_depth)\n"
		"\n"
		"Collect embedded functions from the expression graph.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L426\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L793-L812\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_parse_fmi", _wrap_DaeBuilder_parse_fmi, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  parse_fmi(self, str filename)\n"
		"\n"
		"Import existing problem from FMI/XML\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L433\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L433-L433\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_provides_directional_derivative", (PyCFunction)_wrap_DaeBuilder_provides_directional_derivative, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  provides_directional_derivative(self) -> bool\n"
		"\n"
		"Does the FMU provide support for analytic derivatives.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L436\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L230-L238\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_load_fmi_description", _wrap_DaeBuilder_load_fmi_description, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  load_fmi_description(self, str filename)\n"
		"\n"
		"Import problem description from FMI or XML.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L439\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L222-L228\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_export_fmu", _wrap_DaeBuilder_export_fmu, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  export_fmu(self, dict opts) -> [str]\n"
		"\n"
		"Export instance into an FMU.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L442\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L240-L246\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_lc", _wrap_DaeBuilder_add_lc, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_lc(self, str name, [str] f_out)\n"
		"\n"
		"Add a named linear combination of output expressions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L445\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L711-L718\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_create", _wrap_DaeBuilder_create, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  create(self, str name, dict opts) -> Function\n"
		"  create(self, str name, [str] name_in, [str] name_out, dict opts) -> Function\n"
		"  create(self, str fname, [str] name_in, [str] name_out, bool sx, bool lifted_calls) -> Function\n"
		"\n"
		"Construct a function object, names provided.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name assigned to the resulting function object\n"
		"\n"
		"name_in: \n"
		"Names of all the inputs\n"
		"\n"
		"name_out: \n"
		"Names of all the outputs\n"
		"\n"
		"opts: \n"
		"Optional settings\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L460\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L731-L740\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  create(self, str name, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Load a function from an FMU DLL, standard IO conforming with \n"
		"\n"
		"simulator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name assigned to the resulting function object\n"
		"\n"
		"opts: \n"
		"Optional settings\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L472\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L742-L749\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  create(self, str name, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a function object, names provided.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name assigned to the resulting function object\n"
		"\n"
		"name_in: \n"
		"Names of all the inputs\n"
		"\n"
		"name_out: \n"
		"Names of all the outputs\n"
		"\n"
		"opts: \n"
		"Optional settings\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L460\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L731-L740\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  create(self, str fname, [str] name_in, [str] name_out, bool sx, bool lifted_calls)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a function object, legacy syntax.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L448\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L720-L729\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_dependent_fun", _wrap_DaeBuilder_dependent_fun, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dependent_fun(self, str fname, [str] s_in, [str] s_out) -> Function\n"
		"\n"
		"Construct a function for evaluating dependent parameters.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L475\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L827-L836\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_var", _wrap_DaeBuilder_var, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  var(self, str name) -> MX\n"
		"\n"
		"Get variable expression by name\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L481\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L559-L566\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder___call__", _wrap_DaeBuilder___call__, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  __call__(self, str name) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_beq", _wrap_DaeBuilder_beq, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  beq(self, str name) -> MX\n"
		"\n"
		"Get/set the binding equation for a variable\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L490\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L594-L601\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_beq", _wrap_DaeBuilder_set_beq, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_beq(self, str name, MX val)\n"
		"\n"
		"Get/set the binding equation for a variable\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L491\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L603-L609\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_value_reference", _wrap_DaeBuilder_value_reference, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value_reference(self, str name) -> int\n"
		"\n"
		"Get/set value reference\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L496\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L627-L629\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_value_reference", _wrap_DaeBuilder_set_value_reference, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_value_reference(self, str name, int val)\n"
		"\n"
		"Get/set value reference\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L497\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L631-L633\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_description", _wrap_DaeBuilder_description, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  description(self, str name) -> str\n"
		"\n"
		"Get/set description\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L502\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L635-L637\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_description", _wrap_DaeBuilder_set_description, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_description(self, str name, str val)\n"
		"\n"
		"Get/set description\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L503\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L639-L641\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_type", _wrap_DaeBuilder_type, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type(self, str name, int fmi_version) -> str\n"
		"\n"
		"Get/set the type\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L508\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L643-L652\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_type", _wrap_DaeBuilder_set_type, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_type(self, str name, str val)\n"
		"\n"
		"Get/set the type\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L509\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L654-L661\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_causality", _wrap_DaeBuilder_causality, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  causality(self, str name) -> str\n"
		"\n"
		"Get/set the causality\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L663-L665\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_causality", _wrap_DaeBuilder_set_causality, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_causality(self, str name, str val)\n"
		"\n"
		"Get/set the causality\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L515\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L667-L669\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_variability", _wrap_DaeBuilder_variability, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  variability(self, str name) -> str\n"
		"\n"
		"Get/set the variability\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L520\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L671-L673\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_variability", _wrap_DaeBuilder_set_variability, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_variability(self, str name, str val)\n"
		"\n"
		"Get/set the variability\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L521\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L675-L677\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_initial", _wrap_DaeBuilder_initial, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  initial(self, str name) -> str\n"
		"\n"
		"Get/set the initial property\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L526\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L679-L681\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_initial", _wrap_DaeBuilder_set_initial, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_initial(self, str name, str val)\n"
		"\n"
		"Get/set the initial property\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L527\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L683-L685\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_unit", _wrap_DaeBuilder_unit, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unit(self, str name) -> str\n"
		"\n"
		"Get/set the unit\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L532\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L687-L689\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_unit", _wrap_DaeBuilder_set_unit, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_unit(self, str name, str val)\n"
		"\n"
		"Get/set the unit\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L533\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L691-L693\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_display_unit", _wrap_DaeBuilder_display_unit, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  display_unit(self, str name) -> str\n"
		"\n"
		"Get/set the display unit\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L538\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L695-L697\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_display_unit", _wrap_DaeBuilder_set_display_unit, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_display_unit(self, str name, str val)\n"
		"\n"
		"Get/set the display unit\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L539\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L699-L701\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_numel", _wrap_DaeBuilder_numel, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  numel(self, str name) -> int\n"
		"\n"
		"Get the number of elements of a variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L543\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L703-L705\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_dimension", _wrap_DaeBuilder_dimension, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dimension(self, str name) -> [int]\n"
		"\n"
		"Get the dimensions of a variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L546\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L707-L709\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_der", _wrap_DaeBuilder_der, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  der(self, [str] name) -> [str]\n"
		"  der(self, str name) -> str\n"
		"\n"
		"Get the time derivative of an expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L486\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L583-L592\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  der(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the time derivative of an expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L486\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L583-L592\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  der(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the time derivative of an expression, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L552\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L568-L581\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_reset", (PyCFunction)_wrap_DaeBuilder_reset, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reset(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_attribute", _wrap_DaeBuilder_attribute, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  attribute(self, str a, [str] name) -> [float]\n"
		"  attribute(self, str a, str name) -> float\n"
		"\n"
		"Get an attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L555\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L940-L947\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  attribute(self, str a, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get an attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L555\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L940-L947\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  attribute(self, str a, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get an attribute.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L599\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L949-L957\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_attribute", _wrap_DaeBuilder_set_attribute, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_attribute(self, str a, [str] name, [float] val)\n"
		"  set_attribute(self, str a, str name, float val)\n"
		"\n"
		"Set an attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L558\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L959-L965\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_attribute(self, str a, str name, float val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set an attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L558\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L959-L965\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_attribute(self, str a, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set an attribute.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L602\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L967-L974\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_min", _wrap_DaeBuilder_min, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  min(self, [str] name) -> [float]\n"
		"  min(self, str name) -> float\n"
		"\n"
		"Get the lower bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L561\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L976-L983\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  min(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the lower bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L561\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L976-L983\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  min(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the lower bound.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L606\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L985-L992\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_min", _wrap_DaeBuilder_set_min, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_min(self, [str] name, [float] val)\n"
		"  set_min(self, str name, float val)\n"
		"\n"
		"Set the lower bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L564\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L994-L1000\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_min(self, str name, float val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the lower bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L564\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L994-L1000\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_min(self, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the lower bound.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L609\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1002-L1008\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_max", _wrap_DaeBuilder_max, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  max(self, [str] name) -> [float]\n"
		"  max(self, str name) -> float\n"
		"\n"
		"Get the upper bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L567\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1010-L1017\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  max(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the upper bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L567\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1010-L1017\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  max(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the upper bound.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L612\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1019-L1026\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_max", _wrap_DaeBuilder_set_max, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_max(self, [str] name, [float] val)\n"
		"  set_max(self, str name, float val)\n"
		"\n"
		"Set the upper bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L570\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1028-L1034\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_max(self, str name, float val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the upper bound, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L570\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1028-L1034\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_max(self, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the upper bound.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L615\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1036-L1042\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_nominal", _wrap_DaeBuilder_nominal, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  nominal(self, [str] name) -> [float]\n"
		"  nominal(self, str name) -> float\n"
		"\n"
		"Get the nominal value, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L573\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1044-L1051\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nominal(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the nominal value, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L573\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1044-L1051\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  nominal(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the nominal value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L618\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1053-L1060\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_nominal", _wrap_DaeBuilder_set_nominal, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_nominal(self, [str] name, [float] val)\n"
		"  set_nominal(self, str name, float val)\n"
		"\n"
		"Set the nominal value, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L576\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1062-L1068\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nominal(self, str name, float val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the nominal value, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L576\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1062-L1068\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_nominal(self, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the nominal value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L621\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1070-L1076\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_start", _wrap_DaeBuilder_start, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  start(self, [str] name) -> [float]\n"
		"  start(self, str name) -> float\n"
		"\n"
		"Get the start attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L579\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1078-L1086\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  start(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the start attribute.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L624\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1088-L1095\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  start(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get the start attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L579\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1078-L1086\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set_start", _wrap_DaeBuilder_set_start, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_start(self, [str] name, [float] val)\n"
		"  set_start(self, str name, float val)\n"
		"\n"
		"Set the start attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L582\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1097-L1103\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_start(self, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the start attribute.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L627\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1105-L1111\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_start(self, str name, float val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the start attribute, single variable.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L582\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1097-L1103\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_set", _wrap_DaeBuilder_set, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set(self, [str] name, [float] val)\n"
		"  set(self, [str] name, [str] val)\n"
		"  set(self, str name, float val)\n"
		"  set(self, str name, str val)\n"
		"\n"
		"Set the current value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L630\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1137-L1143\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, [str] name, [str] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the current value (string)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L633\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1145-L1152\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, str name, float val)\n"
		"  set(self, str name, str val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set(self, [str] name, [float] val)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set the current value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L630\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1137-L1143\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_get", _wrap_DaeBuilder_get, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get(self, [str] name) -> [GenericType]\n"
		"  get(self, str name) -> GenericType\n"
		"\n"
		"Evaluate the values for a set of variables at the initial time, \n"
		"single\n"
		" value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L594\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, [str] name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the values for a set of variables at the initial time.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L636\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1158-L1173\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  get(self, str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Evaluate the values for a set of variables at the initial time, \n"
		"single\n"
		" value.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L594\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1154-L1156\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_variable", _wrap_DaeBuilder_add_variable, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_variable(self, MX new_v)\n"
		"  add_variable(self, str name, int n) -> MX\n"
		"  add_variable(self, str name, Sparsity sp) -> MX\n"
		"\n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L642\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L326-L330\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable(self, MX new_v)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable from symbolic expressions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L645\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L332-L335\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable(self, str name, int n)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L639\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L322-L324\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable(self, str name, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L642\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L326-L330\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_add_variable_new", _wrap_DaeBuilder_add_variable_new, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  add_variable_new(self, MX new_v) -> size_t\n"
		"  add_variable_new(self, str name, int n) -> size_t\n"
		"  add_variable_new(self, str name, Sparsity sp) -> size_t\n"
		"\n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L651\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L341-L345\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable_new(self, MX new_v)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable from symbolic expressions.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L654\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L347-L351\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable_new(self, str name, int n)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L648\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L337-L339\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  add_variable_new(self, str name, Sparsity sp)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add a new variable: returns corresponding symbolic expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L651\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L341-L345\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_has_variable", _wrap_DaeBuilder_has_variable, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  has_variable(self, str name) -> bool\n"
		"\n"
		"Check if a particular variable exists.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L657\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L296-L303\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_all_variables", (PyCFunction)_wrap_DaeBuilder_all_variables, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  all_variables(self) -> [str]\n"
		"\n"
		"Get a list of all variables.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L660\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L305-L312\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_oracle", _wrap_DaeBuilder_oracle, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  oracle(self, bool sx, bool elim_w, bool lifted_calls) -> Function\n"
		"\n"
		"Get the (cached) oracle, SX or  MX.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L663\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L818-L825\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_jac_sparsity", _wrap_DaeBuilder_jac_sparsity, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  jac_sparsity(self, [str] onames, [str] inames) -> Sparsity\n"
		"\n"
		"Get Jacobian sparsity.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_6g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L668\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L1175-L1183\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_DaeBuilder", _wrap_new_DaeBuilder, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  DaeBuilder()\n"
		"  DaeBuilder(DaeBuilder other)\n"
		"  DaeBuilder(str name, str path, dict opts)\n"
		"\n"
		"Construct a  DaeBuilder instance.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L80\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L54-L57\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  DaeBuilder(DaeBuilder other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  DaeBuilder(str name, str path, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Construct a  DaeBuilder instance.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L80\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L54-L57\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  DaeBuilder()\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Default constructor.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.hpp#L77\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/dae_builder.cpp#L51-L52\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_DaeBuilder", (PyCFunction)_wrap_delete_DaeBuilder, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  DaeBuilder(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DaeBuilder_swigregister", DaeBuilder_swigregister, METH_VARARGS, NULL},
	 { (char *)"XmlFile_type_name", (PyCFunction)_wrap_XmlFile_type_name, METH_NOARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_name() -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_XmlFile", (PyCFunction)_wrap_delete_XmlFile, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  XmlFile(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"XmlFile_load_plugin", (PyCFunction)_wrap_XmlFile_load_plugin, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  load_plugin(str name)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"XmlFile_doc", (PyCFunction)_wrap_XmlFile_doc, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  doc(str name) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_XmlFile", _wrap_new_XmlFile, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  XmlFile()\n"
		"  XmlFile(XmlFile other)\n"
		"  XmlFile(str name)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  XmlFile(XmlFile other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  XmlFile()\n"
		"  XmlFile(str name)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"XmlFile_swigregister", XmlFile_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_SerializerBase", (PyCFunction)_wrap_delete_SerializerBase, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  SerializerBase(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SerializerBase_pack", _wrap_SerializerBase_pack, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  pack(self, Linsol e)\n"
		"  pack(self, std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const & e)\n"
		"  pack(self, int e)\n"
		"  pack(self, float e)\n"
		"  pack(self, [Sparsity] e)\n"
		"  pack(self, Sparsity e)\n"
		"  pack(self, [float] e)\n"
		"  pack(self, [int] e)\n"
		"  pack(self, [str] e)\n"
		"  pack(self, DM e)\n"
		"  pack(self, [DM] e)\n"
		"  pack(self, SX e)\n"
		"  pack(self, [SX] e)\n"
		"  pack(self, MX e)\n"
		"  pack(self, [MX] e)\n"
		"  pack(self, str e)\n"
		"  pack(self, [Function] e)\n"
		"  pack(self, Function e)\n"
		"  pack(self, [GenericType] e)\n"
		"  pack(self, GenericType e)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  pack(self, DM e)\n"
		"  pack(self, [DM] e)\n"
		"  pack(self, SX e)\n"
		"  pack(self, [SX] e)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  pack(self, Linsol e)\n"
		"  pack(self, std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > const & e)\n"
		"  pack(self, int e)\n"
		"  pack(self, float e)\n"
		"  pack(self, [Sparsity] e)\n"
		"  pack(self, Sparsity e)\n"
		"  pack(self, [float] e)\n"
		"  pack(self, [int] e)\n"
		"  pack(self, [str] e)\n"
		"  pack(self, MX e)\n"
		"  pack(self, [MX] e)\n"
		"  pack(self, str e)\n"
		"  pack(self, [Function] e)\n"
		"  pack(self, Function e)\n"
		"  pack(self, [GenericType] e)\n"
		"  pack(self, GenericType e)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SerializerBase_type_to_string", (PyCFunction)_wrap_SerializerBase_type_to_string, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  type_to_string(casadi::SerializerBase::SerializationType type) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SerializerBase_connect", _wrap_SerializerBase_connect, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  connect(self, DeserializerBase s)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SerializerBase_reset", (PyCFunction)_wrap_SerializerBase_reset, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reset(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"SerializerBase_swigregister", SerializerBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_DeserializerBase", (PyCFunction)_wrap_delete_DeserializerBase, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  DeserializerBase(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase__pop_type", (PyCFunction)_wrap_DeserializerBase__pop_type, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _pop_type(self) -> casadi::SerializerBase::SerializationType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_sparsity", (PyCFunction)_wrap_DeserializerBase_blind_unpack_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_sparsity(self) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_mx", (PyCFunction)_wrap_DeserializerBase_blind_unpack_mx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_mx(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_dm", (PyCFunction)_wrap_DeserializerBase_blind_unpack_dm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_dm(self) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_sx", (PyCFunction)_wrap_DeserializerBase_blind_unpack_sx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_sx(self) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_linsol", (PyCFunction)_wrap_DeserializerBase_blind_unpack_linsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_linsol(self) -> Linsol\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_function", (PyCFunction)_wrap_DeserializerBase_blind_unpack_function, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_function(self) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_generictype", (PyCFunction)_wrap_DeserializerBase_blind_unpack_generictype, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_generictype(self) -> GenericType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_int", (PyCFunction)_wrap_DeserializerBase_blind_unpack_int, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_int(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_double", (PyCFunction)_wrap_DeserializerBase_blind_unpack_double, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_double(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_string", (PyCFunction)_wrap_DeserializerBase_blind_unpack_string, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_string(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_sparsity_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_sparsity_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_sparsity_vector(self) -> [Sparsity]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_mx_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_mx_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_mx_vector(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_dm_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_dm_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_dm_vector(self) -> [DM]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_sx_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_sx_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_sx_vector(self) -> [SX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_linsol_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_linsol_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_linsol_vector(self) -> std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_function_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_function_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_function_vector(self) -> [Function]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_generictype_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_generictype_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_generictype_vector(self) -> [GenericType]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_int_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_int_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_int_vector(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_double_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_double_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_double_vector(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_blind_unpack_string_vector", (PyCFunction)_wrap_DeserializerBase_blind_unpack_string_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  blind_unpack_string_vector(self) -> [str]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_sparsity", (PyCFunction)_wrap_DeserializerBase_unpack_sparsity, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_sparsity(self) -> Sparsity\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_mx", (PyCFunction)_wrap_DeserializerBase_unpack_mx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_mx(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_dm", (PyCFunction)_wrap_DeserializerBase_unpack_dm, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_dm(self) -> DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_sx", (PyCFunction)_wrap_DeserializerBase_unpack_sx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_sx(self) -> SX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_linsol", (PyCFunction)_wrap_DeserializerBase_unpack_linsol, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_linsol(self) -> Linsol\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_function", (PyCFunction)_wrap_DeserializerBase_unpack_function, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_function(self) -> Function\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_generictype", (PyCFunction)_wrap_DeserializerBase_unpack_generictype, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_generictype(self) -> GenericType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_int", (PyCFunction)_wrap_DeserializerBase_unpack_int, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_int(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_double", (PyCFunction)_wrap_DeserializerBase_unpack_double, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_double(self) -> float\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_string", (PyCFunction)_wrap_DeserializerBase_unpack_string, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_string(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_sparsity_vector", (PyCFunction)_wrap_DeserializerBase_unpack_sparsity_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_sparsity_vector(self) -> [Sparsity]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_mx_vector", (PyCFunction)_wrap_DeserializerBase_unpack_mx_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_mx_vector(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_dm_vector", (PyCFunction)_wrap_DeserializerBase_unpack_dm_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_dm_vector(self) -> [DM]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_sx_vector", (PyCFunction)_wrap_DeserializerBase_unpack_sx_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_sx_vector(self) -> [SX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_linsol_vector", (PyCFunction)_wrap_DeserializerBase_unpack_linsol_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_linsol_vector(self) -> std::vector< casadi::Linsol,std::allocator< casadi::Linsol > >\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_function_vector", (PyCFunction)_wrap_DeserializerBase_unpack_function_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_function_vector(self) -> [Function]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_generictype_vector", (PyCFunction)_wrap_DeserializerBase_unpack_generictype_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_generictype_vector(self) -> [GenericType]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_int_vector", (PyCFunction)_wrap_DeserializerBase_unpack_int_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_int_vector(self) -> [int]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_double_vector", (PyCFunction)_wrap_DeserializerBase_unpack_double_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_double_vector(self) -> [float]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_unpack_string_vector", (PyCFunction)_wrap_DeserializerBase_unpack_string_vector, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  unpack_string_vector(self) -> [str]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_connect", _wrap_DeserializerBase_connect, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  connect(self, SerializerBase s)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_reset", (PyCFunction)_wrap_DeserializerBase_reset, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  reset(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"DeserializerBase_swigregister", DeserializerBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringSerializer", _wrap_new_StringSerializer, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  StringSerializer(dict opts)\n"
		"\n"
		"Advanced serialization of CasADi objects.\n"
		"\n"
		"This class is intended for advanced users that want to circumvent the \n"
		"\n"
		"restrictions of standard pickling/matlab save load, ie no raw SX/MX \n"
		"symbols\n"
		" allowed.\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  x = SX.sym('x');\n"
		"  s = StringSerializer();\n"
		"  s.pack(x);\n"
		"  s.pack(sin(x));\n"
		"\n"
		"  data = s.encode();\n"
		"\n"
		"  s = StringDeserializer(data);\n"
		"  a = s.unpack();\n"
		"  b = s.unpack();\n"
		"\n"
		"\n"
		"\n"
		"\n"
		"Note: Saving SX/MX objects individually has a substantial overhead \n"
		"(both \n"
		"time and length of encoded string). You are encouraged to use \n"
		"the \n"
		"vector/list variants of 'save' for SX/MX to reduce the overhead.\n"
		"\n"
		"See: \n"
		" Function::save,  Function::serialize,  StringDeserializer,  \n"
		"FileSerializer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L203\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L37-L39\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_StringSerializer", (PyCFunction)_wrap_delete_StringSerializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  StringSerializer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"StringSerializer_encode", (PyCFunction)_wrap_StringSerializer_encode, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  encode(self) -> str\n"
		"\n"
		"Returns a string that holds the serialized objects.\n"
		"\n"
		"As a side effect, this method clears the internal buffer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L211\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L85-L90\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"StringSerializer_swigregister", StringSerializer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileSerializer", _wrap_new_FileSerializer, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FileSerializer(str fname, dict opts)\n"
		"\n"
		"Advanced serialization of CasADi objects.\n"
		"\n"
		"See: \n"
		" StringSerializer,  FileDeserializer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L221\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L41-L49\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_FileSerializer", (PyCFunction)_wrap_delete_FileSerializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FileSerializer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FileSerializer_swigregister", FileSerializer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringDeserializer", (PyCFunction)_wrap_new_StringDeserializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  StringDeserializer(str string)\n"
		"\n"
		"Advanced deserialization of CasADi objects.\n"
		"\n"
		"See: \n"
		" StringDeserializer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7r\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L233\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L114-L117\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_StringDeserializer", (PyCFunction)_wrap_delete_StringDeserializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  StringDeserializer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"StringDeserializer_decode", _wrap_StringDeserializer_decode, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  decode(self, str string)\n"
		"\n"
		"Sets the string to deserialize objects from.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7s\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L240\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L91-L96\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"StringDeserializer_swigregister", StringDeserializer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileDeserializer", (PyCFunction)_wrap_new_FileDeserializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FileDeserializer(str fname)\n"
		"\n"
		"Advanced deserialization of CasADi objects.\n"
		"\n"
		"See: \n"
		" FileSerializer\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_7t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.hpp#L250\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/serializer.cpp#L106-L112\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_FileDeserializer", (PyCFunction)_wrap_delete_FileDeserializer, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  FileDeserializer(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"FileDeserializer_swigregister", FileDeserializer_swigregister, METH_VARARGS, NULL},
	 { (char *)"Opti__variable", _wrap_Opti__variable, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _variable(self, int n, int m, str attribute) -> MX\n"
		"\n"
		"Create a decision variable (symbol)\n"
		"\n"
		"The order of creation matters. The order will be reflected in the \n"
		"\n"
		"optimization problem. It is not required for decision variables to \n"
		"actualy \n"
		"appear in the optimization problem.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n: \n"
		"number of rows (default 1)\n"
		"\n"
		"m: \n"
		"number of columnss (default 1)\n"
		"\n"
		"attribute: \n"
		"'full' (default) or 'symmetric'\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_18\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L112\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L51-L57\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__parameter", _wrap_Opti__parameter, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _parameter(self, int n, int m, str attribute) -> MX\n"
		"\n"
		"Create a parameter (symbol); fixed during optimization.\n"
		"\n"
		"The order of creation does not matter. It is not required for \n"
		"parameter to \n"
		"actualy appear in the optimization problem. Parameters \n"
		"that do appear, must\n"
		" be given a value before the problem can be \n"
		"solved.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n: \n"
		"number of rows (default 1)\n"
		"\n"
		"m: \n"
		"number of columnss (default 1)\n"
		"\n"
		"attribute: \n"
		"'full' (default) or 'symmetric'\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_19\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L125\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L74-L80\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_minimize", _wrap_Opti_minimize, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  minimize(self, MX f)\n"
		"\n"
		"Set objective.\n"
		"\n"
		"Objective must be a scalar. Default objective: 0 When method is called\n"
		"\n"
		"multiple times, the last call takes effect\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1a\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L133\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L82-L88\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__subject_to", _wrap_Opti__subject_to, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _subject_to(self)\n"
		"  _subject_to(self, MX g)\n"
		"  _subject_to(self, [MX] g)\n"
		"\n"
		"Add constraints.\n"
		"\n"
		"Examples:\n"
		"\n"
		"::\n"
		"\n"
		"  * \\\\begin{itemize}\n"
		"  * opti.subject_to( sqrt(x+y) >= 1);\n"
		"  * opti.subject_to( sqrt(x+y) > 1)}: same as above\n"
		"  * opti.subject_to( 1<= sqrt(x+y) )}: same as above\n"
		"  * opti.subject_to( 5*x+y==1 )}: equality\n"
		"  *\n"
		"  * Python\n"
		"  * opti.subject_to([x*y>=1,x==3])\n"
		"  * opti.subject_to(opti.bounded(0,x,1))\n"
		"  *\n"
		"  * MATLAB\n"
		"  * opti.subject_to({x*y>=1,x==3})\n"
		"  * opti.subject_to( 0<=x<=1 )\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Related functionalities:\n"
		"opti.lbg,opti.g,opti.ubg represent the vector of \n"
		"flattened constraints\n"
		"\n"
		"opti.debug.show_infeasibilities() may be used to inspect which \n"
		"constraints \n"
		"are violated\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L162\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L98-L100\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  _subject_to(self, MX g)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add constraints.\n"
		"\n"
		"Examples:\n"
		"\n"
		"::\n"
		"\n"
		"  * \\\\begin{itemize}\n"
		"  * opti.subject_to( sqrt(x+y) >= 1);\n"
		"  * opti.subject_to( sqrt(x+y) > 1)}: same as above\n"
		"  * opti.subject_to( 1<= sqrt(x+y) )}: same as above\n"
		"  * opti.subject_to( 5*x+y==1 )}: equality\n"
		"  *\n"
		"  * Python\n"
		"  * opti.subject_to([x*y>=1,x==3])\n"
		"  * opti.subject_to(opti.bounded(0,x,1))\n"
		"  *\n"
		"  * MATLAB\n"
		"  * opti.subject_to({x*y>=1,x==3})\n"
		"  * opti.subject_to( 0<=x<=1 )\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Related functionalities:\n"
		"opti.lbg,opti.g,opti.ubg represent the vector of \n"
		"flattened constraints\n"
		"\n"
		"opti.debug.show_infeasibilities() may be used to inspect which \n"
		"constraints \n"
		"are violated\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L161\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L90-L96\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  _subject_to(self, [MX] g)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Add constraints.\n"
		"\n"
		"Examples:\n"
		"\n"
		"::\n"
		"\n"
		"  * \\\\begin{itemize}\n"
		"  * opti.subject_to( sqrt(x+y) >= 1);\n"
		"  * opti.subject_to( sqrt(x+y) > 1)}: same as above\n"
		"  * opti.subject_to( 1<= sqrt(x+y) )}: same as above\n"
		"  * opti.subject_to( 5*x+y==1 )}: equality\n"
		"  *\n"
		"  * Python\n"
		"  * opti.subject_to([x*y>=1,x==3])\n"
		"  * opti.subject_to(opti.bounded(0,x,1))\n"
		"  *\n"
		"  * MATLAB\n"
		"  * opti.subject_to({x*y>=1,x==3})\n"
		"  * opti.subject_to( 0<=x<=1 )\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Related functionalities:\n"
		"opti.lbg,opti.g,opti.ubg represent the vector of \n"
		"flattened constraints\n"
		"\n"
		"opti.debug.show_infeasibilities() may be used to inspect which \n"
		"constraints \n"
		"are violated\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L162\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L98-L100\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  _subject_to(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Clear constraints.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L166\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L102-L108\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_solver", _wrap_Opti_solver, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solver(self, str solver, dict plugin_options, dict solver_options)\n"
		"\n"
		"Set a solver.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"solver: \n"
		"any of the nlpsol plugins can be used here In practice, not all \n"
		"nlpsol\n"
		" plugins may be supported yet\n"
		"\n"
		"options: \n"
		"passed on to nlpsol plugin No stability can be guaranteed about \n"
		"this \n"
		"part of the API\n"
		"\n"
		"options: \n"
		"to be passed to nlpsol solver No stability can be guaranteed about\n"
		"\n"
		"this part of the API\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L178\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L111-L119\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_set_initial", _wrap_Opti_set_initial, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_initial(self, [MX] assignments)\n"
		"  set_initial(self, MX x, DM v)\n"
		"\n"
		"Set initial guess for decision variables\n"
		"\n"
		"::\n"
		"\n"
		"  * opti.set_initial(x, 2)\n"
		"  * opti.set_initial(10*x(1), 2)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L121-L127\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_initial(self, [MX] assignments)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set initial guess for decision variables\n"
		"\n"
		"::\n"
		"\n"
		"  * opti.set_initial(x, 2)\n"
		"  * opti.set_initial(10*x(1), 2)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L190\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L128-L134\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_initial(self, MX x, DM v)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set initial guess for decision variables\n"
		"\n"
		"::\n"
		"\n"
		"  * opti.set_initial(x, 2)\n"
		"  * opti.set_initial(10*x(1), 2)\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L189\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L121-L127\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_set_value", _wrap_Opti_set_value, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_value(self, [MX] assignments)\n"
		"  set_value(self, MX x, DM v)\n"
		"\n"
		"Set value of parameter.\n"
		"\n"
		"Each parameter must be given a value before 'solve' can be called\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L199\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L137-L143\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_value(self, [MX] assignments)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set value of parameter.\n"
		"\n"
		"Each parameter must be given a value before 'solve' can be called\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L200\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L145-L151\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  set_value(self, MX x, DM v)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Set value of parameter.\n"
		"\n"
		"Each parameter must be given a value before 'solve' can be called\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L199\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L137-L143\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_solve", (PyCFunction)_wrap_Opti_solve, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solve(self) -> OptiSol\n"
		"\n"
		"Crunch the numbers; solve the problem.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L204\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L153-L159\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_solve_limited", (PyCFunction)_wrap_Opti_solve_limited, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solve_limited(self) -> OptiSol\n"
		"\n"
		"Crunch the numbers; solve the problem.\n"
		"\n"
		"Allows the solver to return without error when an iteration or time \n"
		"limit \n"
		"is reached\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L212\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L161-L167\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_value", _wrap_Opti_value, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value(self, DM x, [MX] values) -> double\n"
		"  value(self, SX x, [MX] values) -> double\n"
		"  value(self, MX x, [MX] values) -> double\n"
		"\n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L224\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L178-L184\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, DM x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L224\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L178-L184\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, SX x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L225\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L186-L192\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, MX x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L223\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L169-L175\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_stats", (PyCFunction)_wrap_Opti_stats, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  stats(self) -> dict\n"
		"\n"
		"Get statistics.\n"
		"\n"
		"nlpsol stats are passed as-is. No stability can be guaranteed about \n"
		"this \n"
		"part of the API\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L234\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L194-L200\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_return_status", (PyCFunction)_wrap_Opti_return_status, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  return_status(self) -> str\n"
		"\n"
		"Get return status of solver.\n"
		"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"     passed as-is from nlpsol\n"
		"\n"
		"\n"
		"No stability can be guaranteed about this part of the API\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1g\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L242\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L202-L208\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_initial", (PyCFunction)_wrap_Opti_initial, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  initial(self) -> [MX]\n"
		"\n"
		"get assignment expressions for initial values\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_266\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L247\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L210-L216\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_value_variables", (PyCFunction)_wrap_Opti_value_variables, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value_variables(self) -> [MX]\n"
		"\n"
		"get assignment expressions for latest values\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_267\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L252\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L218-L224\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_value_parameters", (PyCFunction)_wrap_Opti_value_parameters, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value_parameters(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_dual", _wrap_Opti_dual, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  dual(self, MX m) -> MX\n"
		"\n"
		"get the dual variable\n"
		"\n"
		"m must be a constraint expression. The returned value is still a \n"
		"symbolic \n"
		"expression. Use  value on it to obtain the numerical value.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1h\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L262\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L234-L240\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__nx", (PyCFunction)_wrap_Opti__nx, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _nx(self) -> int\n"
		"\n"
		"Number of (scalarised) decision variables.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_268\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L267\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L242-L248\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__np", (PyCFunction)_wrap_Opti__np, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _np(self) -> int\n"
		"\n"
		"Number of (scalarised) parameters.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_269\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L272\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L250-L256\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__ng", (PyCFunction)_wrap_Opti__ng, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _ng(self) -> int\n"
		"\n"
		"Number of (scalarised) constraints.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26a\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L277\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L258-L264\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__x", (PyCFunction)_wrap_Opti__x, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _x(self) -> MX\n"
		"\n"
		"Get all (scalarised) decision variables as a symbolic column \n"
		"vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26b\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L282\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L266-L272\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__p", (PyCFunction)_wrap_Opti__p, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _p(self) -> MX\n"
		"\n"
		"Get all (scalarised) parameters as a symbolic column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26c\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L287\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L274-L280\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__g", (PyCFunction)_wrap_Opti__g, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _g(self) -> MX\n"
		"\n"
		"Get all (scalarised) constraint expressions as a column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26d\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L292\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L282-L288\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__f", (PyCFunction)_wrap_Opti__f, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _f(self) -> MX\n"
		"\n"
		"Get objective expression.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26e\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L297\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L290-L296\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__lbg", (PyCFunction)_wrap_Opti__lbg, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _lbg(self) -> MX\n"
		"\n"
		"Get all (scalarised) bounds on constraints as a column vector.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_26f\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L302\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L298-L304\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__ubg", (PyCFunction)_wrap_Opti__ubg, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _ubg(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__lam_g", (PyCFunction)_wrap_Opti__lam_g, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _lam_g(self) -> MX\n"
		"\n"
		"Get all (scalarised) dual variables as a symbolic column vector.\n"
		"\n"
		"Useful for obtaining the Lagrange Hessian:\n"
		"\n"
		"::\n"
		"\n"
		"  * sol.value(hessian(opti.f+opti.lam_g'*opti.g,opti.x)) % MATLAB\n"
		"  * sol.value(hessian(opti.f+dot(opti.lam_g,opti.g),opti.x)[0]) # Python\n"
		"  * \n"
		"\n"
		"\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1i\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L314\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L315-L321\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_to_function", _wrap_Opti_to_function, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  to_function(self, str name, [MX] args, [MX] res, dict opts) -> Function\n"
		"  to_function(self, str name, dict:MX dict, [str] name_in, [str] name_out, dict opts) -> Function\n"
		"  to_function(self, str name, [MX] args, [MX] res, [str] name_in, [str] name_out, dict opts) -> Function\n"
		"\n"
		"Create a CasADi  Function from the  Opti solver.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of the resulting CasADi  Function\n"
		"\n"
		"args: \n"
		"List of parameters and decision/dual variables (which can be given an\n"
		"\n"
		"initial guess) with the resulting  Function\n"
		"\n"
		"res: \n"
		"List of expressions that will get evaluated at the optimal solution\n"
		"\n"
		"opts: \n"
		"Standard CasADi Funcion options\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L330\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L323-L333\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  to_function(self, str name, [MX] args, [MX] res, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a CasADi  Function from the  Opti solver.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of the resulting CasADi  Function\n"
		"\n"
		"args: \n"
		"List of parameters and decision/dual variables (which can be given an\n"
		"\n"
		"initial guess) with the resulting  Function\n"
		"\n"
		"res: \n"
		"List of expressions that will get evaluated at the optimal solution\n"
		"\n"
		"opts: \n"
		"Standard CasADi Funcion options\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L326\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L335-L339\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  to_function(self, str name, dict:MX dict, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a CasADi  Function from the  Opti solver.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of the resulting CasADi  Function\n"
		"\n"
		"args: \n"
		"List of parameters and decision/dual variables (which can be given an\n"
		"\n"
		"initial guess) with the resulting  Function\n"
		"\n"
		"res: \n"
		"List of expressions that will get evaluated at the optimal solution\n"
		"\n"
		"opts: \n"
		"Standard CasADi Funcion options\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L336\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L341-L361\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  to_function(self, str name, [MX] args, [MX] res, [str] name_in, [str] name_out, dict opts)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create a CasADi  Function from the  Opti solver.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name: \n"
		"Name of the resulting CasADi  Function\n"
		"\n"
		"args: \n"
		"List of parameters and decision/dual variables (which can be given an\n"
		"\n"
		"initial guess) with the resulting  Function\n"
		"\n"
		"res: \n"
		"List of expressions that will get evaluated at the optimal solution\n"
		"\n"
		"opts: \n"
		"Standard CasADi Funcion options\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1j\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L330\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L323-L333\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_bounded", _wrap_Opti_bounded, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  bounded(MX lb, MX expr, MX ub) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__debug", (PyCFunction)_wrap_Opti__debug, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _debug(self) -> OptiAdvanced\n"
		"\n"
		"Get a copy with advanced functionality.\n"
		"\n"
		"You get access to more methods, but you have no guarantees about API \n"
		"\n"
		"stability\n"
		"\n"
		"The copy is effectively a deep copy: Updating the state of the copy \n"
		"does \n"
		"not update the original.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1l\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L362\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L733-L735\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti__advanced", (PyCFunction)_wrap_Opti__advanced, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _advanced(self) -> OptiAdvanced\n"
		"\n"
		"Get a copy with advanced functionality.\n"
		"\n"
		"You get access to more methods, but you have no guarantees about API \n"
		"\n"
		"stability\n"
		"\n"
		"The copy is effectively a deep copy: Updating the state of the copy \n"
		"does \n"
		"not update the original.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1m\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L372\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L736-L738\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_copy", (PyCFunction)_wrap_Opti_copy, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  copy(self) -> Opti\n"
		"\n"
		"Get a copy of the.\n"
		"\n"
		"The copy is effectively a deep copy: Updating the state of the copy \n"
		"does \n"
		"not update the original.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1n\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L380\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L739-L741\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_update_user_dict", _wrap_Opti_update_user_dict, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  update_user_dict(self, MX m, dict meta)\n"
		"  update_user_dict(self, [MX] m, dict meta)\n"
		"\n"
		"add user data\n"
		"\n"
		"Add arbitrary data in the form of a dictionary to symbols or \n"
		"constraints\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L388\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L379-L385\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  update_user_dict(self, MX m, dict meta)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"add user data\n"
		"\n"
		"Add arbitrary data in the form of a dictionary to symbols or \n"
		"constraints\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1o\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L388\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L379-L385\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  update_user_dict(self, [MX] m, dict meta)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_user_dict", _wrap_Opti_user_dict, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  user_dict(self, MX m) -> dict\n"
		"\n"
		"Get user data.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L391\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L392-L398\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_type_name", (PyCFunction)_wrap_Opti_type_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type_name(self) -> str\n"
		"\n"
		"Readable name of the class.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L394\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L394-L394\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_disp", _wrap_Opti_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"Print representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L397\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L636-L656\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_str", _wrap_Opti_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"Get string representation.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L400\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L658-L662\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_callback_class", _wrap_Opti_callback_class, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  callback_class(self)\n"
		"  callback_class(self, OptiCallback callback)\n"
		"\n"
		"Helper methods for callback()\n"
		"\n"
		"Do not use directly.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L408\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L363-L369\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  callback_class(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Helper methods for callback()\n"
		"\n"
		"Do not use directly.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L409\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L371-L377\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  callback_class(self, OptiCallback callback)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Helper methods for callback()\n"
		"\n"
		"Do not use directly.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1p\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L408\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L363-L369\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_Opti", _wrap_new_Opti, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Opti(str problem_type)\n"
		"  Opti(Opti other)\n"
		"\n"
		"Create  Opti Context.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"problem_type: \n"
		"of optimization 'nlp' or 'conic' (default nlp)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_17\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L47-L49\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Opti(Opti other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  Opti(str problem_type)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Create  Opti Context.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"problem_type: \n"
		"of optimization 'nlp' or 'conic' (default nlp)\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_17\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L99\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L47-L49\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_Opti", (PyCFunction)_wrap_delete_Opti, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  Opti(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1q\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L418\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L418-L418\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"Opti_swigregister", Opti_swigregister, METH_VARARGS, NULL},
	 { (char *)"IndexAbstraction_start_get", (PyCFunction)_wrap_IndexAbstraction_start_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  IndexAbstraction_start_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"IndexAbstraction_stop_get", (PyCFunction)_wrap_IndexAbstraction_stop_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  IndexAbstraction_stop_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_IndexAbstraction", _wrap_new_IndexAbstraction, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  IndexAbstraction()\n"
		"  IndexAbstraction(IndexAbstraction other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_IndexAbstraction", (PyCFunction)_wrap_delete_IndexAbstraction, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  IndexAbstraction(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"IndexAbstraction_swigregister", IndexAbstraction_swigregister, METH_VARARGS, NULL},
	 { (char *)"MetaCon_original_get", (PyCFunction)_wrap_MetaCon_original_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_original_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_canon_get", (PyCFunction)_wrap_MetaCon_canon_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_canon_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_type_get", (PyCFunction)_wrap_MetaCon_type_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_type_get(self) -> casadi::ConstraintType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_lb_get", (PyCFunction)_wrap_MetaCon_lb_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_lb_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_ub_get", (PyCFunction)_wrap_MetaCon_ub_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_ub_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_n_get", (PyCFunction)_wrap_MetaCon_n_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_n_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_flipped_get", (PyCFunction)_wrap_MetaCon_flipped_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_flipped_get(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_dual_canon_get", (PyCFunction)_wrap_MetaCon_dual_canon_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_dual_canon_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_dual_get", (PyCFunction)_wrap_MetaCon_dual_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_dual_get(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_extra_get", (PyCFunction)_wrap_MetaCon_extra_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon_extra_get(self) -> dict\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_MetaCon", _wrap_new_MetaCon, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon()\n"
		"  MetaCon(MetaCon other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_MetaCon", (PyCFunction)_wrap_delete_MetaCon, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaCon(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaCon_swigregister", MetaCon_swigregister, METH_VARARGS, NULL},
	 { (char *)"MetaVar_attribute_get", (PyCFunction)_wrap_MetaVar_attribute_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_attribute_get(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_n_get", (PyCFunction)_wrap_MetaVar_n_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_n_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_m_get", (PyCFunction)_wrap_MetaVar_m_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_m_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_type_get", (PyCFunction)_wrap_MetaVar_type_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_type_get(self) -> casadi::VariableType\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_count_get", (PyCFunction)_wrap_MetaVar_count_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_count_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_i_get", (PyCFunction)_wrap_MetaVar_i_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_i_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_active_i_get", (PyCFunction)_wrap_MetaVar_active_i_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_active_i_get(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_extra_get", (PyCFunction)_wrap_MetaVar_extra_get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar_extra_get(self) -> dict\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_MetaVar", _wrap_new_MetaVar, METH_VARARGS, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar()\n"
		"  MetaVar(MetaVar other)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_MetaVar", (PyCFunction)_wrap_delete_MetaVar, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  MetaVar(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"MetaVar_swigregister", MetaVar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OptiCallback", _wrap_new_OptiCallback, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  OptiCallback(self)\n"
		"  OptiCallback(self, OptiCallback obj)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiCallback_call", _wrap_OptiCallback_call, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  call(self, int i)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"delete_OptiCallback", (PyCFunction)_wrap_delete_OptiCallback, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  OptiCallback(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"disown_OptiCallback", (PyCFunction)_wrap_disown_OptiCallback, METH_O, NULL},
	 { (char *)"OptiCallback_swigregister", OptiCallback_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_OptiAdvanced", (PyCFunction)_wrap_delete_OptiAdvanced, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced(self)\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1t\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L507\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L507-L507\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced__casadi_solver", (PyCFunction)_wrap_OptiAdvanced__casadi_solver, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _casadi_solver(self) -> Function\n"
		"\n"
		"Get the underlying CasADi solver of the  Opti stack.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L511\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L400-L406\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_is_parametric", _wrap_OptiAdvanced_is_parametric, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  is_parametric(self, MX expr) -> bool\n"
		"\n"
		"return true if expression is only dependant on  Opti parameters,\n"
		" not variables\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L514\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L408-L414\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_symvar", _wrap_OptiAdvanced_symvar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  symvar(self) -> [MX]\n"
		"  symvar(self, MX expr) -> [MX]\n"
		"  symvar(self, MX expr, casadi::VariableType type) -> [MX]\n"
		"\n"
		"Get symbols present in expression.\n"
		"\n"
		"Returned vector is ordered according to the order of  variable()/parameter()\n"
		" calls used to create the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L524\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L424-L430\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  symvar(self)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbols present in expression.\n"
		"\n"
		"Returned vector is ordered according to the order of  variable()/parameter()\n"
		" calls used to create the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L523\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L416-L422\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  symvar(self, MX expr)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbols present in expression.\n"
		"\n"
		"Returned vector is ordered according to the order of  variable()/parameter()\n"
		" calls used to create the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L524\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L424-L430\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  symvar(self, MX expr, casadi::VariableType type)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Get symbols present in expression.\n"
		"\n"
		"Returned vector is ordered according to the order of  variable()/parameter()\n"
		" calls used to create the variables\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1u\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L525\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L432-L438\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_canon_expr", _wrap_OptiAdvanced_canon_expr, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  canon_expr(self, MX expr) -> MetaCon\n"
		"\n"
		"Interpret an expression (for internal use only)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L529\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L440-L446\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_get_meta", _wrap_OptiAdvanced_get_meta, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_meta(self, MX m) -> MetaVar\n"
		"\n"
		"Get meta-data of symbol (for internal use only)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L532\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L448-L454\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_get_meta_con", _wrap_OptiAdvanced_get_meta_con, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  get_meta_con(self, MX m) -> MetaCon\n"
		"\n"
		"Get meta-data of symbol (for internal use only)\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L535\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L456-L462\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_set_meta", _wrap_OptiAdvanced_set_meta, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_meta(self, MX m, MetaVar meta)\n"
		"\n"
		"Set meta-data of an expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L538\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L464-L470\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_set_meta_con", _wrap_OptiAdvanced_set_meta_con, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  set_meta_con(self, MX m, MetaCon meta)\n"
		"\n"
		"Set meta-data of an expression.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L541\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L472-L478\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_assert_active_symbol", _wrap_OptiAdvanced_assert_active_symbol, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_active_symbol(self, MX m)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_active_symvar", _wrap_OptiAdvanced_active_symvar, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  active_symvar(self, casadi::VariableType type) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_active_values", _wrap_OptiAdvanced_active_values, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  active_values(self, casadi::VariableType type) -> [DM]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_x_lookup", _wrap_OptiAdvanced_x_lookup, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  x_lookup(self, int i) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_g_lookup", _wrap_OptiAdvanced_g_lookup, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  g_lookup(self, int i) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_x_describe", _wrap_OptiAdvanced_x_describe, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  x_describe(self, int i) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_g_describe", _wrap_OptiAdvanced_g_describe, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  g_describe(self, int i) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_describe", _wrap_OptiAdvanced_describe, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  describe(self, MX x, int indent) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_show_infeasibilities", _wrap_OptiAdvanced_show_infeasibilities, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  show_infeasibilities(self, float tol)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solve_prepare", (PyCFunction)_wrap_OptiAdvanced_solve_prepare, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solve_prepare(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solve_actual", _wrap_OptiAdvanced_solve_actual, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solve_actual(self, dict:DM args) -> dict:DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_arg", (PyCFunction)_wrap_OptiAdvanced_arg, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  arg(self) -> dict:DM\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_res", _wrap_OptiAdvanced_res, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  res(self) -> dict:DM\n"
		"  res(self, dict:DM res)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_constraints", (PyCFunction)_wrap_OptiAdvanced_constraints, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  constraints(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_objective", (PyCFunction)_wrap_OptiAdvanced_objective, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  objective(self) -> MX\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_baked_copy", (PyCFunction)_wrap_OptiAdvanced_baked_copy, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  baked_copy(self) -> OptiAdvanced\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_assert_empty", (PyCFunction)_wrap_OptiAdvanced_assert_empty, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_empty(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_bake", (PyCFunction)_wrap_OptiAdvanced_bake, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  bake(self)\n"
		"\n"
		"Fix the structure of the optimization problem.\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L572\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L664-L670\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_problem_dirty__get", (PyCFunction)_wrap_OptiAdvanced_problem_dirty__get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced_problem_dirty__get(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_mark_problem_dirty", _wrap_OptiAdvanced_mark_problem_dirty, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mark_problem_dirty(self, bool flag)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_problem_dirty", (PyCFunction)_wrap_OptiAdvanced_problem_dirty, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  problem_dirty(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solver_dirty__get", (PyCFunction)_wrap_OptiAdvanced_solver_dirty__get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced_solver_dirty__get(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_mark_solver_dirty", _wrap_OptiAdvanced_mark_solver_dirty, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mark_solver_dirty(self, bool flag)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solver_dirty", (PyCFunction)_wrap_OptiAdvanced_solver_dirty, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solver_dirty(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solved__get", (PyCFunction)_wrap_OptiAdvanced_solved__get, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced_solved__get(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_mark_solved", _wrap_OptiAdvanced_mark_solved, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  mark_solved(self, bool flag)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_solved", (PyCFunction)_wrap_OptiAdvanced_solved, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  solved(self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_assert_solved", (PyCFunction)_wrap_OptiAdvanced_assert_solved, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_solved(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_assert_baked", (PyCFunction)_wrap_OptiAdvanced_assert_baked, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  assert_baked(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_instance_number", (PyCFunction)_wrap_OptiAdvanced_instance_number, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  instance_number(self) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_OptiAdvanced", _wrap_new_OptiAdvanced, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced(OptiAdvanced other)\n"
		"  OptiAdvanced(Opti x)\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced(OptiAdvanced other)\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  OptiAdvanced(Opti x)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiAdvanced_swigregister", OptiAdvanced_swigregister, METH_VARARGS, NULL},
	 { (char *)"OptiSol_type_name", (PyCFunction)_wrap_OptiSol_type_name, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  type_name(self) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_disp", _wrap_OptiSol_disp, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  disp(self, bool more)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_str", _wrap_OptiSol_str, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  str(self, bool more) -> str\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_value", _wrap_OptiSol_value, METH_VARARGS, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value(self, DM x, [MX] values) -> double\n"
		"  value(self, SX x, [MX] values) -> double\n"
		"  value(self, MX x, [MX] values) -> double\n"
		"\n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L621\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L757-L759\n"
		"\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, DM x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L621\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L757-L759\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, SX x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L622\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L760-L762\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		".......\n"
		"\n"
		"::\n"
		"\n"
		"  value(self, MX x, [MX] values)\n"
		"\n"
		"\n"
		"\n"
		"[INTERNAL] \n"
		"Obtain value of expression at the current value\n"
		"\n"
		"In regular mode, teh current value is the converged solution In debug \n"
		"mode,\n"
		" the value can be non-converged\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"values: \n"
		"Optional assignment expressions (e.g. x==3) to overrule the current\n"
		"\n"
		"value\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L620\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L754-L756\n"
		"\n"
		"\n"
		"\n"
		".............\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_value_variables", (PyCFunction)_wrap_OptiSol_value_variables, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value_variables(self) -> [MX]\n"
		"\n"
		"get assignment expressions for the optimal solution\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L626\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L764-L766\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_value_parameters", (PyCFunction)_wrap_OptiSol_value_parameters, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  value_parameters(self) -> [MX]\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_stats", (PyCFunction)_wrap_OptiSol_stats, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  stats(self) -> dict\n"
		"\n"
		"Get statistics.\n"
		"\n"
		"nlpsol stats are passed as-is. No stability can be guaranteed about \n"
		"this \n"
		"part of the API\n"
		"\n"
		"Extra doc: https://github.com/casadi/casadi/wiki/L_1w\n"
		"\n"
		"Doc source: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.hpp#L635\n"
		"\n"
		"Implementation: \n"
		"https://github.com/casadi/casadi/blob/develop/casadi/core/optistack.cpp#L772-L774\n"
		"\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol__opti", (PyCFunction)_wrap_OptiSol__opti, METH_O, (char *)"\n"
		"  [INTERNAL] \n"
		"\n"
		"::\n"
		"\n"
		"  _opti(self) -> Opti\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"new_OptiSol", _wrap_new_OptiSol, METH_VARARGS, NULL},
	 { (char *)"delete_OptiSol", (PyCFunction)_wrap_delete_OptiSol, METH_O, (char *)"\n"
		"\n"
		"\n"
		"::\n"
		"\n"
		"  OptiSol(self)\n"
		"\n"
		"\n"
		"\n"
		""},
	 { (char *)"OptiSol_swigregister", OptiSol_swigregister, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_tTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *)  ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) x));
}
static void *_p_casadi__GenericMatrixT_casadi__MX_tTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *)  ((casadi::GenericMatrix< casadi::MX > *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *) (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_tTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *)  ((casadi::GenericMatrix< casadi::Matrix< double > > *) x));
}
static void *_p_casadi__SparsityTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *)  ((casadi::Sparsity *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *) (casadi::GenericMatrix< casadi::Matrix< double > > *) ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__MXTo_p_casadi__SparsityInterfaceCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SparsityInterfaceCommon *) (casadi::GenericMatrix< casadi::MX > *) ((casadi::MX *) x));
}
static void *_p_casadi__SliceTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Slice *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__OptiAdvancedTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *) (casadi::Opti *) ((casadi::OptiAdvanced *) x));
}
static void *_p_casadi__SparsityTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Sparsity *) x));
}
static void *_p_casadi__FunctionTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Function *) x));
}
static void *_p_casadi__OptiTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Opti *) x));
}
static void *_p_casadi__CallbackTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *) (casadi::Function *) ((casadi::Callback *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__OptiSolTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::OptiSol *) x));
}
static void *_p_casadi__DaeBuilderTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::DaeBuilder *) x));
}
static void *_p_casadi__NlpBuilderTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::NlpBuilder *) x));
}
static void *_p_casadi__GenericTypeTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::GenericType *) x));
}
static void *_p_casadi__MXTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::MX *) x));
}
static void *_p_casadi__LinsolTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Linsol *) x));
}
static void *_p_casadi__ImporterTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Importer *) x));
}
static void *_p_casadi__XmlFileTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::XmlFile *) x));
}
static void *_p_casadi__MatrixT_long_long_tTo_p_casadi__PrintableCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::PrintableCommon *)  ((casadi::Matrix< long long > *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__MatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::MatrixCommon *)  ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__MatrixT_long_long_tTo_p_casadi__MatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::MatrixCommon *)  ((casadi::Matrix< long long > *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__MatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::MatrixCommon *)  ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericExpressionCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericExpressionCommon *)  ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__MatrixT_long_long_tTo_p_casadi__GenericExpressionCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericExpressionCommon *)  ((casadi::Matrix< long long > *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__GenericExpressionCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericExpressionCommon *)  ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__MXTo_p_casadi__GenericExpressionCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericExpressionCommon *)  ((casadi::MX *) x));
}
static void *_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_tTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *)  ((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) x));
}
static void *_p_casadi__GenericMatrixT_casadi__MX_tTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *)  ((casadi::GenericMatrix< casadi::MX > *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *) (casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *) ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_tTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *)  ((casadi::GenericMatrix< casadi::Matrix< double > > *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *) (casadi::GenericMatrix< casadi::Matrix< double > > *) ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__MXTo_p_casadi__GenericMatrixCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrixCommon *) (casadi::GenericMatrix< casadi::MX > *) ((casadi::MX *) x));
}
static void *_p_casadi__OptiAdvancedTo_p_casadi__Opti(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::Opti *)  ((casadi::OptiAdvanced *) x));
}
static void *_p_casadi__CallbackTo_p_casadi__Function(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::Function *)  ((casadi::Callback *) x));
}
static void *_p_casadi__DaeBuilderTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::DaeBuilder *) x));
}
static void *_p_casadi__OptiTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::Opti *) x));
}
static void *_p_casadi__FunctionTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::Function *) x));
}
static void *_p_casadi__ImporterTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::Importer *) x));
}
static void *_p_casadi__SparsityTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::Sparsity *) x));
}
static void *_p_casadi__MXTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::MX *) x));
}
static void *_p_casadi__CallbackTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *) (casadi::Function *) ((casadi::Callback *) x));
}
static void *_p_casadi__XmlFileTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::XmlFile *) x));
}
static void *_p_casadi__WeakRefTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::WeakRef *) x));
}
static void *_p_casadi__LinsolTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *)  ((casadi::Linsol *) x));
}
static void *_p_casadi__OptiAdvancedTo_p_casadi__SharedObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SharedObject *) (casadi::Opti *) ((casadi::OptiAdvanced *) x));
}
static void *_p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *)  ((casadi::Matrix< casadi::SXElem > *) x));
}
static void *_p_casadi__StringDeserializerTo_p_casadi__DeserializerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::DeserializerBase *)  ((casadi::StringDeserializer *) x));
}
static void *_p_casadi__FileDeserializerTo_p_casadi__DeserializerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::DeserializerBase *)  ((casadi::FileDeserializer *) x));
}
static void *_p_casadi__StringSerializerTo_p_casadi__SerializerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SerializerBase *)  ((casadi::StringSerializer *) x));
}
static void *_p_casadi__FileSerializerTo_p_casadi__SerializerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::SerializerBase *)  ((casadi::FileSerializer *) x));
}
static void *_p_casadi__MXTo_p_casadi__GenericMatrixT_casadi__MX_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrix< casadi::MX > *)  ((casadi::MX *) x));
}
static void *_p_casadi__MatrixT_double_tTo_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::GenericMatrix< casadi::Matrix< double > > *)  ((casadi::Matrix< double > *) x));
}
static void *_p_casadi__MetaConTo_p_casadi__IndexAbstraction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::IndexAbstraction *)  ((casadi::MetaCon *) x));
}
static void *_p_casadi__MetaVarTo_p_casadi__IndexAbstraction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((casadi::IndexAbstraction *)  ((casadi::MetaVar *) x));
}
static swig_type_info _swigt__p_AuxOut = {"_p_AuxOut", "AuxOut *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dict = {"_p_Dict", "Dict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MXDict = {"_p_MXDict", "MXDict *", 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_casadi__Callback = {"_p_casadi__Callback", "casadi::Callback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__CasadiMeta = {"_p_casadi__CasadiMeta", "casadi::CasadiMeta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__CodeGenerator = {"_p_casadi__CodeGenerator", "casadi::CodeGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__DaeBuilder = {"_p_casadi__DaeBuilder", "casadi::DaeBuilder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__DeserializerBase = {"_p_casadi__DeserializerBase", "casadi::DeserializerBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__DeserializingStream = {"_p_casadi__DeserializingStream", "casadi::DeserializingStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__FileDeserializer = {"_p_casadi__FileDeserializer", "casadi::FileDeserializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__FileSerializer = {"_p_casadi__FileSerializer", "casadi::FileSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Function = {"_p_casadi__Function", "casadi::Function *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__FunctionBuffer = {"_p_casadi__FunctionBuffer", "casadi::FunctionBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GenericExpressionCommon = {"_p_casadi__GenericExpressionCommon", "casadi::GenericExpressionCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MatrixT_long_long_t = {"_p_casadi__MatrixT_long_long_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_casadi__GenericMatrixCommon = {"_p_casadi__GenericMatrixCommon", "casadi::GenericMatrixCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GenericMatrixT_casadi__MX_t = {"_p_casadi__GenericMatrixT_casadi__MX_t", "casadi::GenericMatrix< casadi::MX > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t = {"_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t", "casadi::GenericMatrix< casadi::Matrix< casadi::SXElem > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t = {"_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t", "casadi::GenericMatrix< casadi::Matrix< double > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GenericType = {"_p_casadi__GenericType", "casadi::GenericType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__GlobalOptions = {"_p_casadi__GlobalOptions", "casadi::GlobalOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Importer = {"_p_casadi__Importer", "casadi::Importer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__IndexAbstraction = {"_p_casadi__IndexAbstraction", "casadi::IndexAbstraction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Linsol = {"_p_casadi__Linsol", "casadi::Linsol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MX = {"_p_casadi__MX", "casadi::MX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MatrixCommon = {"_p_casadi__MatrixCommon", "casadi::MatrixCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MatrixT_casadi__SXElem_t = {"_p_casadi__MatrixT_casadi__SXElem_t", "casadi::Matrix< casadi::SXElem > *|casadi::SX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MatrixT_double_t = {"_p_casadi__MatrixT_double_t", "casadi::DM *|casadi::Matrix< double > *|casadi::native_DM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MetaCon = {"_p_casadi__MetaCon", "casadi::MetaCon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__MetaVar = {"_p_casadi__MetaVar", "casadi::MetaVar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__NlpBuilder = {"_p_casadi__NlpBuilder", "casadi::NlpBuilder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Opti = {"_p_casadi__Opti", "casadi::Opti *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__OptiAdvanced = {"_p_casadi__OptiAdvanced", "casadi::OptiAdvanced *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__OptiCallback = {"_p_casadi__OptiCallback", "casadi::OptiCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__OptiSol = {"_p_casadi__OptiSol", "casadi::OptiSol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__PrintableCommon = {"_p_casadi__PrintableCommon", "casadi::PrintableCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SXElem = {"_p_casadi__SXElem", "casadi::SXElem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SerializerBase = {"_p_casadi__SerializerBase", "casadi::SerializerBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SerializingStream = {"_p_casadi__SerializingStream", "casadi::SerializingStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SharedObject = {"_p_casadi__SharedObject", "casadi::SharedObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SharedObjectInternal = {"_p_casadi__SharedObjectInternal", "casadi::SharedObjectInternal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Slice = {"_p_casadi__Slice", "casadi::Slice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__Sparsity = {"_p_casadi__Sparsity", "casadi::Sparsity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__SparsityInterfaceCommon = {"_p_casadi__SparsityInterfaceCommon", "casadi::SparsityInterfaceCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__StringDeserializer = {"_p_casadi__StringDeserializer", "casadi::StringDeserializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__StringSerializer = {"_p_casadi__StringSerializer", "casadi::StringSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__WeakRef = {"_p_casadi__WeakRef", "casadi::WeakRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_casadi__XmlFile = {"_p_casadi__XmlFile", "casadi::XmlFile *", 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_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 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_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "casadi_index *|long long *|casadi_int *", 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_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__initializer_listT_casadi__MX_t = {"_p_std__initializer_listT_casadi__MX_t", "casadi::MXIList *|std::initializer_list< casadi::MX > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t = {"_p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t", "std::initializer_list< casadi::Matrix< casadi::SXElem > > *|casadi::SXIList *", 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__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t = {"_p_std__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t", "std::map< std::string,casadi::GenericType,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::GenericType > > > *|casadi::Dict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t = {"_p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t", "std::map< std::string,casadi::MX,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::MX > > > *|casadi::MXDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t = {"_p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t", "std::map< std::string,casadi::Matrix< casadi::SXElem >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< casadi::SXElem > > > > *|casadi::SXDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t = {"_p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t", "std::map< std::string,casadi::Matrix< double >,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Matrix< double > > > > *|casadi::DMDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t = {"_p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t", "std::map< std::string,casadi::Sparsity,std::less< std::string >,std::allocator< std::pair< std::string const,casadi::Sparsity > > > *|casadi::SpDict *", 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__pairT_casadi__Slice_casadi__Slice_t = {"_p_std__pairT_casadi__Slice_casadi__Slice_t", "std::pair< casadi::Slice,casadi::Slice > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t = {"_p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t", "std::vector< casadi::Linsol,std::allocator< casadi::Linsol > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t = {"_p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t", "std::vector< casadi::MX,std::allocator< casadi::MX > > *|casadi::MXVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t = {"_p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t", "std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > *|casadi::SXVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t = {"_p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t", "std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > *|casadi::DMVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t = {"_p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t", "std::vector< std::vector< casadi::MX,std::allocator< casadi::MX > >,std::allocator< std::vector< casadi::MX,std::allocator< casadi::MX > > > > *|casadi::MXVectorVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t", "std::vector< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > >,std::allocator< std::vector< casadi::Matrix< casadi::SXElem >,std::allocator< casadi::Matrix< casadi::SXElem > > > > > *|casadi::SXVectorVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t", "std::vector< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > >,std::allocator< std::vector< casadi::Matrix< double >,std::allocator< casadi::Matrix< double > > > > > *|casadi::DMVectorVector *", 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_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_AuxOut,
  &_swigt__p_Dict,
  &_swigt__p_MXDict,
  &_swigt__p_allocator_type,
  &_swigt__p_casadi__Callback,
  &_swigt__p_casadi__CasadiMeta,
  &_swigt__p_casadi__CodeGenerator,
  &_swigt__p_casadi__DaeBuilder,
  &_swigt__p_casadi__DeserializerBase,
  &_swigt__p_casadi__DeserializingStream,
  &_swigt__p_casadi__FileDeserializer,
  &_swigt__p_casadi__FileSerializer,
  &_swigt__p_casadi__Function,
  &_swigt__p_casadi__FunctionBuffer,
  &_swigt__p_casadi__GenericExpressionCommon,
  &_swigt__p_casadi__GenericMatrixCommon,
  &_swigt__p_casadi__GenericMatrixT_casadi__MX_t,
  &_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t,
  &_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t,
  &_swigt__p_casadi__GenericType,
  &_swigt__p_casadi__GlobalOptions,
  &_swigt__p_casadi__Importer,
  &_swigt__p_casadi__IndexAbstraction,
  &_swigt__p_casadi__Linsol,
  &_swigt__p_casadi__MX,
  &_swigt__p_casadi__MatrixCommon,
  &_swigt__p_casadi__MatrixT_casadi__SXElem_t,
  &_swigt__p_casadi__MatrixT_double_t,
  &_swigt__p_casadi__MatrixT_long_long_t,
  &_swigt__p_casadi__MetaCon,
  &_swigt__p_casadi__MetaVar,
  &_swigt__p_casadi__NlpBuilder,
  &_swigt__p_casadi__Opti,
  &_swigt__p_casadi__OptiAdvanced,
  &_swigt__p_casadi__OptiCallback,
  &_swigt__p_casadi__OptiSol,
  &_swigt__p_casadi__PrintableCommon,
  &_swigt__p_casadi__SXElem,
  &_swigt__p_casadi__SerializerBase,
  &_swigt__p_casadi__SerializingStream,
  &_swigt__p_casadi__SharedObject,
  &_swigt__p_casadi__SharedObjectInternal,
  &_swigt__p_casadi__Slice,
  &_swigt__p_casadi__Sparsity,
  &_swigt__p_casadi__SparsityInterfaceCommon,
  &_swigt__p_casadi__StringDeserializer,
  &_swigt__p_casadi__StringSerializer,
  &_swigt__p_casadi__WeakRef,
  &_swigt__p_casadi__XmlFile,
  &_swigt__p_char,
  &_swigt__p_const_reference,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_first_type,
  &_swigt__p_key_type,
  &_swigt__p_long_long,
  &_swigt__p_mapped_type,
  &_swigt__p_p_double,
  &_swigt__p_reference,
  &_swigt__p_second_type,
  &_swigt__p_size_type,
  &_swigt__p_std__initializer_listT_casadi__MX_t,
  &_swigt__p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__istream,
  &_swigt__p_std__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t,
  &_swigt__p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t,
  &_swigt__p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t,
  &_swigt__p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t,
  &_swigt__p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t,
  &_swigt__p_std__ostream,
  &_swigt__p_std__pairT_casadi__Slice_casadi__Slice_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t,
  &_swigt__p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t,
  &_swigt__p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t,
  &_swigt__p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_AuxOut[] = {  {&_swigt__p_AuxOut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dict[] = {  {&_swigt__p_Dict, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MXDict[] = {  {&_swigt__p_MXDict, 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_casadi__Callback[] = {  {&_swigt__p_casadi__Callback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__CasadiMeta[] = {  {&_swigt__p_casadi__CasadiMeta, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__CodeGenerator[] = {  {&_swigt__p_casadi__CodeGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__DaeBuilder[] = {  {&_swigt__p_casadi__DaeBuilder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__DeserializerBase[] = {  {&_swigt__p_casadi__DeserializerBase, 0, 0, 0},  {&_swigt__p_casadi__StringDeserializer, _p_casadi__StringDeserializerTo_p_casadi__DeserializerBase, 0, 0},  {&_swigt__p_casadi__FileDeserializer, _p_casadi__FileDeserializerTo_p_casadi__DeserializerBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__DeserializingStream[] = {  {&_swigt__p_casadi__DeserializingStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__FileDeserializer[] = {  {&_swigt__p_casadi__FileDeserializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__FileSerializer[] = {  {&_swigt__p_casadi__FileSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Function[] = {  {&_swigt__p_casadi__Function, 0, 0, 0},  {&_swigt__p_casadi__Callback, _p_casadi__CallbackTo_p_casadi__Function, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__FunctionBuffer[] = {  {&_swigt__p_casadi__FunctionBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MatrixT_long_long_t[] = {{&_swigt__p_casadi__MatrixT_long_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericExpressionCommon[] = {  {&_swigt__p_casadi__GenericExpressionCommon, 0, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__GenericExpressionCommon, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__GenericExpressionCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericExpressionCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_long_long_t, _p_casadi__MatrixT_long_long_tTo_p_casadi__GenericExpressionCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericMatrixCommon[] = {  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, _p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_tTo_p_casadi__GenericMatrixCommon, 0, 0},  {&_swigt__p_casadi__GenericMatrixT_casadi__MX_t, _p_casadi__GenericMatrixT_casadi__MX_tTo_p_casadi__GenericMatrixCommon, 0, 0},  {&_swigt__p_casadi__GenericMatrixCommon, 0, 0, 0},  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, _p_casadi__GenericMatrixT_casadi__MatrixT_double_t_tTo_p_casadi__GenericMatrixCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__GenericMatrixCommon, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__GenericMatrixCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericMatrixCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericMatrixT_casadi__MX_t[] = {  {&_swigt__p_casadi__GenericMatrixT_casadi__MX_t, 0, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__GenericMatrixT_casadi__MX_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t[] = {  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t[] = {  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GenericType[] = {  {&_swigt__p_casadi__GenericType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__GlobalOptions[] = {  {&_swigt__p_casadi__GlobalOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Importer[] = {  {&_swigt__p_casadi__Importer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__IndexAbstraction[] = {  {&_swigt__p_casadi__IndexAbstraction, 0, 0, 0},  {&_swigt__p_casadi__MetaCon, _p_casadi__MetaConTo_p_casadi__IndexAbstraction, 0, 0},  {&_swigt__p_casadi__MetaVar, _p_casadi__MetaVarTo_p_casadi__IndexAbstraction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Linsol[] = {  {&_swigt__p_casadi__Linsol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MX[] = {  {&_swigt__p_casadi__MX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MatrixCommon[] = {  {&_swigt__p_casadi__MatrixCommon, 0, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__MatrixCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__MatrixCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_long_long_t, _p_casadi__MatrixT_long_long_tTo_p_casadi__MatrixCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MatrixT_casadi__SXElem_t[] = {  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MatrixT_double_t[] = {  {&_swigt__p_casadi__MatrixT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MetaCon[] = {  {&_swigt__p_casadi__MetaCon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__MetaVar[] = {  {&_swigt__p_casadi__MetaVar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__NlpBuilder[] = {  {&_swigt__p_casadi__NlpBuilder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Opti[] = {  {&_swigt__p_casadi__Opti, 0, 0, 0},  {&_swigt__p_casadi__OptiAdvanced, _p_casadi__OptiAdvancedTo_p_casadi__Opti, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__OptiAdvanced[] = {  {&_swigt__p_casadi__OptiAdvanced, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__OptiCallback[] = {  {&_swigt__p_casadi__OptiCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__OptiSol[] = {  {&_swigt__p_casadi__OptiSol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__PrintableCommon[] = {  {&_swigt__p_casadi__MatrixT_long_long_t, _p_casadi__MatrixT_long_long_tTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Opti, _p_casadi__OptiTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__OptiAdvanced, _p_casadi__OptiAdvancedTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Slice, _p_casadi__SliceTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Sparsity, _p_casadi__SparsityTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Function, _p_casadi__FunctionTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__PrintableCommon, 0, 0, 0},  {&_swigt__p_casadi__Callback, _p_casadi__CallbackTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__OptiSol, _p_casadi__OptiSolTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__DaeBuilder, _p_casadi__DaeBuilderTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__NlpBuilder, _p_casadi__NlpBuilderTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Linsol, _p_casadi__LinsolTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__GenericType, _p_casadi__GenericTypeTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__Importer, _p_casadi__ImporterTo_p_casadi__PrintableCommon, 0, 0},  {&_swigt__p_casadi__XmlFile, _p_casadi__XmlFileTo_p_casadi__PrintableCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SXElem[] = {  {&_swigt__p_casadi__SXElem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SerializerBase[] = {  {&_swigt__p_casadi__SerializerBase, 0, 0, 0},  {&_swigt__p_casadi__StringSerializer, _p_casadi__StringSerializerTo_p_casadi__SerializerBase, 0, 0},  {&_swigt__p_casadi__FileSerializer, _p_casadi__FileSerializerTo_p_casadi__SerializerBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SerializingStream[] = {  {&_swigt__p_casadi__SerializingStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SharedObject[] = {  {&_swigt__p_casadi__Linsol, _p_casadi__LinsolTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__DaeBuilder, _p_casadi__DaeBuilderTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__Function, _p_casadi__FunctionTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__SharedObject, 0, 0, 0},  {&_swigt__p_casadi__Importer, _p_casadi__ImporterTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__Opti, _p_casadi__OptiTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__Sparsity, _p_casadi__SparsityTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__Callback, _p_casadi__CallbackTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__XmlFile, _p_casadi__XmlFileTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__OptiAdvanced, _p_casadi__OptiAdvancedTo_p_casadi__SharedObject, 0, 0},  {&_swigt__p_casadi__WeakRef, _p_casadi__WeakRefTo_p_casadi__SharedObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SharedObjectInternal[] = {  {&_swigt__p_casadi__SharedObjectInternal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Slice[] = {  {&_swigt__p_casadi__Slice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__Sparsity[] = {  {&_swigt__p_casadi__Sparsity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__SparsityInterfaceCommon[] = {  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t, _p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_tTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__GenericMatrixT_casadi__MX_t, _p_casadi__GenericMatrixT_casadi__MX_tTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t, _p_casadi__GenericMatrixT_casadi__MatrixT_double_t_tTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_double_t, _p_casadi__MatrixT_double_tTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__SparsityInterfaceCommon, 0, 0, 0},  {&_swigt__p_casadi__MX, _p_casadi__MXTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__MatrixT_casadi__SXElem_t, _p_casadi__MatrixT_casadi__SXElem_tTo_p_casadi__SparsityInterfaceCommon, 0, 0},  {&_swigt__p_casadi__Sparsity, _p_casadi__SparsityTo_p_casadi__SparsityInterfaceCommon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__StringDeserializer[] = {  {&_swigt__p_casadi__StringDeserializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__StringSerializer[] = {  {&_swigt__p_casadi__StringSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__WeakRef[] = {  {&_swigt__p_casadi__WeakRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_casadi__XmlFile[] = {  {&_swigt__p_casadi__XmlFile, 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_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{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_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_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 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_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__initializer_listT_casadi__MX_t[] = {  {&_swigt__p_std__initializer_listT_casadi__MX_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t[] = {  {&_swigt__p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_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__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_casadi__Slice_casadi__Slice_t[] = {  {&_swigt__p_std__pairT_casadi__Slice_casadi__Slice_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t[] = {  {&_swigt__p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t[] = {  {&_swigt__p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t[] = {  {&_swigt__p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t[] = {  {&_swigt__p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_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_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_AuxOut,
  _swigc__p_Dict,
  _swigc__p_MXDict,
  _swigc__p_allocator_type,
  _swigc__p_casadi__Callback,
  _swigc__p_casadi__CasadiMeta,
  _swigc__p_casadi__CodeGenerator,
  _swigc__p_casadi__DaeBuilder,
  _swigc__p_casadi__DeserializerBase,
  _swigc__p_casadi__DeserializingStream,
  _swigc__p_casadi__FileDeserializer,
  _swigc__p_casadi__FileSerializer,
  _swigc__p_casadi__Function,
  _swigc__p_casadi__FunctionBuffer,
  _swigc__p_casadi__GenericExpressionCommon,
  _swigc__p_casadi__GenericMatrixCommon,
  _swigc__p_casadi__GenericMatrixT_casadi__MX_t,
  _swigc__p_casadi__GenericMatrixT_casadi__MatrixT_casadi__SXElem_t_t,
  _swigc__p_casadi__GenericMatrixT_casadi__MatrixT_double_t_t,
  _swigc__p_casadi__GenericType,
  _swigc__p_casadi__GlobalOptions,
  _swigc__p_casadi__Importer,
  _swigc__p_casadi__IndexAbstraction,
  _swigc__p_casadi__Linsol,
  _swigc__p_casadi__MX,
  _swigc__p_casadi__MatrixCommon,
  _swigc__p_casadi__MatrixT_casadi__SXElem_t,
  _swigc__p_casadi__MatrixT_double_t,
  _swigc__p_casadi__MatrixT_long_long_t,
  _swigc__p_casadi__MetaCon,
  _swigc__p_casadi__MetaVar,
  _swigc__p_casadi__NlpBuilder,
  _swigc__p_casadi__Opti,
  _swigc__p_casadi__OptiAdvanced,
  _swigc__p_casadi__OptiCallback,
  _swigc__p_casadi__OptiSol,
  _swigc__p_casadi__PrintableCommon,
  _swigc__p_casadi__SXElem,
  _swigc__p_casadi__SerializerBase,
  _swigc__p_casadi__SerializingStream,
  _swigc__p_casadi__SharedObject,
  _swigc__p_casadi__SharedObjectInternal,
  _swigc__p_casadi__Slice,
  _swigc__p_casadi__Sparsity,
  _swigc__p_casadi__SparsityInterfaceCommon,
  _swigc__p_casadi__StringDeserializer,
  _swigc__p_casadi__StringSerializer,
  _swigc__p_casadi__WeakRef,
  _swigc__p_casadi__XmlFile,
  _swigc__p_char,
  _swigc__p_const_reference,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_first_type,
  _swigc__p_key_type,
  _swigc__p_long_long,
  _swigc__p_mapped_type,
  _swigc__p_p_double,
  _swigc__p_reference,
  _swigc__p_second_type,
  _swigc__p_size_type,
  _swigc__p_std__initializer_listT_casadi__MX_t,
  _swigc__p_std__initializer_listT_casadi__MatrixT_casadi__SXElem_t_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__istream,
  _swigc__p_std__mapT_std__string_casadi__GenericType_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__GenericType_t_t_t,
  _swigc__p_std__mapT_std__string_casadi__MX_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MX_t_t_t,
  _swigc__p_std__mapT_std__string_casadi__MatrixT_casadi__SXElem_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_casadi__SXElem_t_t_t_t,
  _swigc__p_std__mapT_std__string_casadi__MatrixT_double_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__MatrixT_double_t_t_t_t,
  _swigc__p_std__mapT_std__string_casadi__Sparsity_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_casadi__Sparsity_t_t_t,
  _swigc__p_std__ostream,
  _swigc__p_std__pairT_casadi__Slice_casadi__Slice_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_casadi__Linsol_std__allocatorT_casadi__Linsol_t_t,
  _swigc__p_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t,
  _swigc__p_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t,
  _swigc__p_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_std__allocatorT_std__vectorT_casadi__MX_std__allocatorT_casadi__MX_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_casadi__SXElem_t_std__allocatorT_casadi__MatrixT_casadi__SXElem_t_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_std__allocatorT_std__vectorT_casadi__MatrixT_double_t_std__allocatorT_casadi__MatrixT_double_t_t_t_t_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_value_type,
};


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


SWIGRUNTIME void
SWIG_InitializeModule(void *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 %d\n", 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 %d %s\n", 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 %d %s\n", 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
  
  /* 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(swig_varlinkobject *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(swig_varlinkobject *v) {
#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 int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    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(swig_varlinkobject *v, char *n, PyObject *p) {
    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 = {
        /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (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 */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
        0,                                  /* tp_prev */
#endif
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    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, 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) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * 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);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    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;
        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;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#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;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) 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 = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyObject *metatype_args;
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  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;
  
  /* metatype is used to implement static member variables. */
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
  assert(metatype_args);
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
  assert(metatype);
  Py_DECREF(metatype_args);
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
  assert(PyType_Ready(metatype) >= 0);
#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((char *) SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  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_TypeOnce();
  } else if (SwigPyObject_TypeOnce()->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, "CASADI_INT_TYPE_STR",SWIG_FromCharPtr("long long int"));
  SWIG_Python_SetConstant(d, "SOLVER_RET_SUCCESS",SWIG_From_int(static_cast< int >(casadi::SOLVER_RET_SUCCESS)));
  SWIG_Python_SetConstant(d, "SOLVER_RET_UNKNOWN",SWIG_From_int(static_cast< int >(casadi::SOLVER_RET_UNKNOWN)));
  SWIG_Python_SetConstant(d, "SOLVER_RET_LIMITED",SWIG_From_int(static_cast< int >(casadi::SOLVER_RET_LIMITED)));
  SWIG_Python_SetConstant(d, "SOLVER_RET_NAN",SWIG_From_int(static_cast< int >(casadi::SOLVER_RET_NAN)));
  SWIG_Python_SetConstant(d, "SOLVER_RET_INFEASIBLE",SWIG_From_int(static_cast< int >(casadi::SOLVER_RET_INFEASIBLE)));
  
  // Set logger functions
  casadi::Logger::writeFun = casadi::pythonlogger;
  
  // @jgillis: please document
  casadi::InterruptHandler::checkInterrupted = casadi::pythoncheckinterrupted;
  
  casadi::InterruptHandler::is_main_thread();
  
  
  SWIG_Python_SetConstant(d, "MNAME",SWIG_FromCharPtr("$name"));
  SWIG_Python_SetConstant(d, "L_INT",SWIG_FromCharPtr("int"));
  SWIG_Python_SetConstant(d, "L_BOOL",SWIG_FromCharPtr("bool"));
  SWIG_Python_SetConstant(d, "LL",SWIG_FromCharPtr("["));
  SWIG_Python_SetConstant(d, "LR",SWIG_FromCharPtr("]"));
  SWIG_Python_SetConstant(d, "L_DICT",SWIG_FromCharPtr("dict"));
  SWIG_Python_SetConstant(d, "L_DOUBLE",SWIG_FromCharPtr("float"));
  SWIG_Python_SetConstant(d, "L_STR",SWIG_FromCharPtr("str"));
  SWIG_Python_SetConstant(d, "LABEL",SWIG_FromCharPtr("(int,int)"));
  SWIG_Python_SetConstant(d, "SWIG_IND1",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "OP_ASSIGN",SWIG_From_int(static_cast< int >(casadi::OP_ASSIGN)));
  SWIG_Python_SetConstant(d, "OP_ADD",SWIG_From_int(static_cast< int >(casadi::OP_ADD)));
  SWIG_Python_SetConstant(d, "OP_SUB",SWIG_From_int(static_cast< int >(casadi::OP_SUB)));
  SWIG_Python_SetConstant(d, "OP_MUL",SWIG_From_int(static_cast< int >(casadi::OP_MUL)));
  SWIG_Python_SetConstant(d, "OP_DIV",SWIG_From_int(static_cast< int >(casadi::OP_DIV)));
  SWIG_Python_SetConstant(d, "OP_NEG",SWIG_From_int(static_cast< int >(casadi::OP_NEG)));
  SWIG_Python_SetConstant(d, "OP_EXP",SWIG_From_int(static_cast< int >(casadi::OP_EXP)));
  SWIG_Python_SetConstant(d, "OP_LOG",SWIG_From_int(static_cast< int >(casadi::OP_LOG)));
  SWIG_Python_SetConstant(d, "OP_POW",SWIG_From_int(static_cast< int >(casadi::OP_POW)));
  SWIG_Python_SetConstant(d, "OP_CONSTPOW",SWIG_From_int(static_cast< int >(casadi::OP_CONSTPOW)));
  SWIG_Python_SetConstant(d, "OP_SQRT",SWIG_From_int(static_cast< int >(casadi::OP_SQRT)));
  SWIG_Python_SetConstant(d, "OP_SQ",SWIG_From_int(static_cast< int >(casadi::OP_SQ)));
  SWIG_Python_SetConstant(d, "OP_TWICE",SWIG_From_int(static_cast< int >(casadi::OP_TWICE)));
  SWIG_Python_SetConstant(d, "OP_SIN",SWIG_From_int(static_cast< int >(casadi::OP_SIN)));
  SWIG_Python_SetConstant(d, "OP_COS",SWIG_From_int(static_cast< int >(casadi::OP_COS)));
  SWIG_Python_SetConstant(d, "OP_TAN",SWIG_From_int(static_cast< int >(casadi::OP_TAN)));
  SWIG_Python_SetConstant(d, "OP_ASIN",SWIG_From_int(static_cast< int >(casadi::OP_ASIN)));
  SWIG_Python_SetConstant(d, "OP_ACOS",SWIG_From_int(static_cast< int >(casadi::OP_ACOS)));
  SWIG_Python_SetConstant(d, "OP_ATAN",SWIG_From_int(static_cast< int >(casadi::OP_ATAN)));
  SWIG_Python_SetConstant(d, "OP_LT",SWIG_From_int(static_cast< int >(casadi::OP_LT)));
  SWIG_Python_SetConstant(d, "OP_LE",SWIG_From_int(static_cast< int >(casadi::OP_LE)));
  SWIG_Python_SetConstant(d, "OP_EQ",SWIG_From_int(static_cast< int >(casadi::OP_EQ)));
  SWIG_Python_SetConstant(d, "OP_NE",SWIG_From_int(static_cast< int >(casadi::OP_NE)));
  SWIG_Python_SetConstant(d, "OP_NOT",SWIG_From_int(static_cast< int >(casadi::OP_NOT)));
  SWIG_Python_SetConstant(d, "OP_AND",SWIG_From_int(static_cast< int >(casadi::OP_AND)));
  SWIG_Python_SetConstant(d, "OP_OR",SWIG_From_int(static_cast< int >(casadi::OP_OR)));
  SWIG_Python_SetConstant(d, "OP_FLOOR",SWIG_From_int(static_cast< int >(casadi::OP_FLOOR)));
  SWIG_Python_SetConstant(d, "OP_CEIL",SWIG_From_int(static_cast< int >(casadi::OP_CEIL)));
  SWIG_Python_SetConstant(d, "OP_FMOD",SWIG_From_int(static_cast< int >(casadi::OP_FMOD)));
  SWIG_Python_SetConstant(d, "OP_FABS",SWIG_From_int(static_cast< int >(casadi::OP_FABS)));
  SWIG_Python_SetConstant(d, "OP_SIGN",SWIG_From_int(static_cast< int >(casadi::OP_SIGN)));
  SWIG_Python_SetConstant(d, "OP_COPYSIGN",SWIG_From_int(static_cast< int >(casadi::OP_COPYSIGN)));
  SWIG_Python_SetConstant(d, "OP_IF_ELSE_ZERO",SWIG_From_int(static_cast< int >(casadi::OP_IF_ELSE_ZERO)));
  SWIG_Python_SetConstant(d, "OP_ERF",SWIG_From_int(static_cast< int >(casadi::OP_ERF)));
  SWIG_Python_SetConstant(d, "OP_FMIN",SWIG_From_int(static_cast< int >(casadi::OP_FMIN)));
  SWIG_Python_SetConstant(d, "OP_FMAX",SWIG_From_int(static_cast< int >(casadi::OP_FMAX)));
  SWIG_Python_SetConstant(d, "OP_INV",SWIG_From_int(static_cast< int >(casadi::OP_INV)));
  SWIG_Python_SetConstant(d, "OP_SINH",SWIG_From_int(static_cast< int >(casadi::OP_SINH)));
  SWIG_Python_SetConstant(d, "OP_COSH",SWIG_From_int(static_cast< int >(casadi::OP_COSH)));
  SWIG_Python_SetConstant(d, "OP_TANH",SWIG_From_int(static_cast< int >(casadi::OP_TANH)));
  SWIG_Python_SetConstant(d, "OP_ASINH",SWIG_From_int(static_cast< int >(casadi::OP_ASINH)));
  SWIG_Python_SetConstant(d, "OP_ACOSH",SWIG_From_int(static_cast< int >(casadi::OP_ACOSH)));
  SWIG_Python_SetConstant(d, "OP_ATANH",SWIG_From_int(static_cast< int >(casadi::OP_ATANH)));
  SWIG_Python_SetConstant(d, "OP_ATAN2",SWIG_From_int(static_cast< int >(casadi::OP_ATAN2)));
  SWIG_Python_SetConstant(d, "OP_CONST",SWIG_From_int(static_cast< int >(casadi::OP_CONST)));
  SWIG_Python_SetConstant(d, "OP_INPUT",SWIG_From_int(static_cast< int >(casadi::OP_INPUT)));
  SWIG_Python_SetConstant(d, "OP_OUTPUT",SWIG_From_int(static_cast< int >(casadi::OP_OUTPUT)));
  SWIG_Python_SetConstant(d, "OP_PARAMETER",SWIG_From_int(static_cast< int >(casadi::OP_PARAMETER)));
  SWIG_Python_SetConstant(d, "OP_CALL",SWIG_From_int(static_cast< int >(casadi::OP_CALL)));
  SWIG_Python_SetConstant(d, "OP_FIND",SWIG_From_int(static_cast< int >(casadi::OP_FIND)));
  SWIG_Python_SetConstant(d, "OP_LOW",SWIG_From_int(static_cast< int >(casadi::OP_LOW)));
  SWIG_Python_SetConstant(d, "OP_MAP",SWIG_From_int(static_cast< int >(casadi::OP_MAP)));
  SWIG_Python_SetConstant(d, "OP_MTIMES",SWIG_From_int(static_cast< int >(casadi::OP_MTIMES)));
  SWIG_Python_SetConstant(d, "OP_SOLVE",SWIG_From_int(static_cast< int >(casadi::OP_SOLVE)));
  SWIG_Python_SetConstant(d, "OP_TRANSPOSE",SWIG_From_int(static_cast< int >(casadi::OP_TRANSPOSE)));
  SWIG_Python_SetConstant(d, "OP_DETERMINANT",SWIG_From_int(static_cast< int >(casadi::OP_DETERMINANT)));
  SWIG_Python_SetConstant(d, "OP_INVERSE",SWIG_From_int(static_cast< int >(casadi::OP_INVERSE)));
  SWIG_Python_SetConstant(d, "OP_DOT",SWIG_From_int(static_cast< int >(casadi::OP_DOT)));
  SWIG_Python_SetConstant(d, "OP_BILIN",SWIG_From_int(static_cast< int >(casadi::OP_BILIN)));
  SWIG_Python_SetConstant(d, "OP_RANK1",SWIG_From_int(static_cast< int >(casadi::OP_RANK1)));
  SWIG_Python_SetConstant(d, "OP_HORZCAT",SWIG_From_int(static_cast< int >(casadi::OP_HORZCAT)));
  SWIG_Python_SetConstant(d, "OP_VERTCAT",SWIG_From_int(static_cast< int >(casadi::OP_VERTCAT)));
  SWIG_Python_SetConstant(d, "OP_DIAGCAT",SWIG_From_int(static_cast< int >(casadi::OP_DIAGCAT)));
  SWIG_Python_SetConstant(d, "OP_HORZSPLIT",SWIG_From_int(static_cast< int >(casadi::OP_HORZSPLIT)));
  SWIG_Python_SetConstant(d, "OP_VERTSPLIT",SWIG_From_int(static_cast< int >(casadi::OP_VERTSPLIT)));
  SWIG_Python_SetConstant(d, "OP_DIAGSPLIT",SWIG_From_int(static_cast< int >(casadi::OP_DIAGSPLIT)));
  SWIG_Python_SetConstant(d, "OP_RESHAPE",SWIG_From_int(static_cast< int >(casadi::OP_RESHAPE)));
  SWIG_Python_SetConstant(d, "OP_SUBREF",SWIG_From_int(static_cast< int >(casadi::OP_SUBREF)));
  SWIG_Python_SetConstant(d, "OP_SUBASSIGN",SWIG_From_int(static_cast< int >(casadi::OP_SUBASSIGN)));
  SWIG_Python_SetConstant(d, "OP_GETNONZEROS",SWIG_From_int(static_cast< int >(casadi::OP_GETNONZEROS)));
  SWIG_Python_SetConstant(d, "OP_GETNONZEROS_PARAM",SWIG_From_int(static_cast< int >(casadi::OP_GETNONZEROS_PARAM)));
  SWIG_Python_SetConstant(d, "OP_ADDNONZEROS",SWIG_From_int(static_cast< int >(casadi::OP_ADDNONZEROS)));
  SWIG_Python_SetConstant(d, "OP_ADDNONZEROS_PARAM",SWIG_From_int(static_cast< int >(casadi::OP_ADDNONZEROS_PARAM)));
  SWIG_Python_SetConstant(d, "OP_SETNONZEROS",SWIG_From_int(static_cast< int >(casadi::OP_SETNONZEROS)));
  SWIG_Python_SetConstant(d, "OP_SETNONZEROS_PARAM",SWIG_From_int(static_cast< int >(casadi::OP_SETNONZEROS_PARAM)));
  SWIG_Python_SetConstant(d, "OP_PROJECT",SWIG_From_int(static_cast< int >(casadi::OP_PROJECT)));
  SWIG_Python_SetConstant(d, "OP_ASSERTION",SWIG_From_int(static_cast< int >(casadi::OP_ASSERTION)));
  SWIG_Python_SetConstant(d, "OP_MONITOR",SWIG_From_int(static_cast< int >(casadi::OP_MONITOR)));
  SWIG_Python_SetConstant(d, "OP_NORM2",SWIG_From_int(static_cast< int >(casadi::OP_NORM2)));
  SWIG_Python_SetConstant(d, "OP_NORM1",SWIG_From_int(static_cast< int >(casadi::OP_NORM1)));
  SWIG_Python_SetConstant(d, "OP_NORMINF",SWIG_From_int(static_cast< int >(casadi::OP_NORMINF)));
  SWIG_Python_SetConstant(d, "OP_NORMF",SWIG_From_int(static_cast< int >(casadi::OP_NORMF)));
  SWIG_Python_SetConstant(d, "OP_MMIN",SWIG_From_int(static_cast< int >(casadi::OP_MMIN)));
  SWIG_Python_SetConstant(d, "OP_MMAX",SWIG_From_int(static_cast< int >(casadi::OP_MMAX)));
  SWIG_Python_SetConstant(d, "OP_HORZREPMAT",SWIG_From_int(static_cast< int >(casadi::OP_HORZREPMAT)));
  SWIG_Python_SetConstant(d, "OP_HORZREPSUM",SWIG_From_int(static_cast< int >(casadi::OP_HORZREPSUM)));
  SWIG_Python_SetConstant(d, "OP_ERFINV",SWIG_From_int(static_cast< int >(casadi::OP_ERFINV)));
  SWIG_Python_SetConstant(d, "OP_PRINTME",SWIG_From_int(static_cast< int >(casadi::OP_PRINTME)));
  SWIG_Python_SetConstant(d, "OP_LIFT",SWIG_From_int(static_cast< int >(casadi::OP_LIFT)));
  SWIG_Python_SetConstant(d, "OP_EINSTEIN",SWIG_From_int(static_cast< int >(casadi::OP_EINSTEIN)));
  SWIG_Python_SetConstant(d, "OP_BSPLINE",SWIG_From_int(static_cast< int >(casadi::OP_BSPLINE)));
  SWIG_Python_SetConstant(d, "OP_CONVEXIFY",SWIG_From_int(static_cast< int >(casadi::OP_CONVEXIFY)));
  SWIG_Python_SetConstant(d, "OP_SPARSITY_CAST",SWIG_From_int(static_cast< int >(casadi::OP_SPARSITY_CAST)));
  SWIG_Python_SetConstant(d, "OP_LOG1P",SWIG_From_int(static_cast< int >(casadi::OP_LOG1P)));
  SWIG_Python_SetConstant(d, "OP_EXPM1",SWIG_From_int(static_cast< int >(casadi::OP_EXPM1)));
  SWIG_Python_SetConstant(d, "OP_HYPOT",SWIG_From_int(static_cast< int >(casadi::OP_HYPOT)));
  SWIG_Python_SetConstant(d, "OP_LOGSUMEXP",SWIG_From_int(static_cast< int >(casadi::OP_LOGSUMEXP)));
  SWIG_Python_SetConstant(d, "OP_REMAINDER",SWIG_From_int(static_cast< int >(casadi::OP_REMAINDER)));
  SWIG_Python_SetConstant(d, "IS_GLOBAL",SWIG_From_int(static_cast< int >(0x1)));
  SWIG_Python_SetConstant(d, "IS_MEMBER",SWIG_From_int(static_cast< int >(0x10)));
  SWIG_Python_SetConstant(d, "IS_SPARSITY",SWIG_From_int(static_cast< int >(0x100)));
  SWIG_Python_SetConstant(d, "IS_DMATRIX",SWIG_From_int(static_cast< int >(0x1000)));
  SWIG_Python_SetConstant(d, "IS_IMATRIX",SWIG_From_int(static_cast< int >(0x10000)));
  SWIG_Python_SetConstant(d, "IS_SX",SWIG_From_int(static_cast< int >(0x100000)));
  SWIG_Python_SetConstant(d, "IS_MX",SWIG_From_int(static_cast< int >(0x1000000)));
  SWIG_Python_SetConstant(d, "IS_DOUBLE",SWIG_From_int(static_cast< int >(0x10000000)));
  SWIG_Python_SetConstant(d, "FLAG",SWIG_From_int(static_cast< int >((0x1|0x10))));
  SWIG_Python_SetConstant(d, "LEGENDRE",SWIG_From_int(static_cast< int >(casadi::LEGENDRE)));
  SWIG_Python_SetConstant(d, "RADAU",SWIG_From_int(static_cast< int >(casadi::RADAU)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_SPARSITY",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_SPARSITY)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_MX",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_MX)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_DM",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_DM)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_SX",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_SX)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_LINSOL",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_LINSOL)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_FUNCTION",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_FUNCTION)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_GENERICTYPE",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_GENERICTYPE)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_INT",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_INT)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_DOUBLE",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_DOUBLE)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_STRING",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_STRING)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_SPARSITY_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_SPARSITY_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_MX_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_MX_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_DM_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_DM_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_SX_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_SX_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_LINSOL_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_LINSOL_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_FUNCTION_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_FUNCTION_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_GENERICTYPE_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_GENERICTYPE_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_INT_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_INT_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_DOUBLE_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_DOUBLE_VECTOR)));
  SWIG_Python_SetConstant(d, "SerializerBase__SERIALIZED_STRING_VECTOR",SWIG_From_int(static_cast< int >(casadi::SerializerBase::SERIALIZED_STRING_VECTOR)));
  SWIG_Python_SetConstant(d, "OPTI_GENERIC_EQUALITY",SWIG_From_int(static_cast< int >(casadi::OPTI_GENERIC_EQUALITY)));
  SWIG_Python_SetConstant(d, "OPTI_GENERIC_INEQUALITY",SWIG_From_int(static_cast< int >(casadi::OPTI_GENERIC_INEQUALITY)));
  SWIG_Python_SetConstant(d, "OPTI_EQUALITY",SWIG_From_int(static_cast< int >(casadi::OPTI_EQUALITY)));
  SWIG_Python_SetConstant(d, "OPTI_INEQUALITY",SWIG_From_int(static_cast< int >(casadi::OPTI_INEQUALITY)));
  SWIG_Python_SetConstant(d, "OPTI_DOUBLE_INEQUALITY",SWIG_From_int(static_cast< int >(casadi::OPTI_DOUBLE_INEQUALITY)));
  SWIG_Python_SetConstant(d, "OPTI_PSD",SWIG_From_int(static_cast< int >(casadi::OPTI_PSD)));
  SWIG_Python_SetConstant(d, "OPTI_UNKNOWN",SWIG_From_int(static_cast< int >(casadi::OPTI_UNKNOWN)));
  SWIG_Python_SetConstant(d, "OPTI_VAR",SWIG_From_int(static_cast< int >(casadi::OPTI_VAR)));
  SWIG_Python_SetConstant(d, "OPTI_PAR",SWIG_From_int(static_cast< int >(casadi::OPTI_PAR)));
  SWIG_Python_SetConstant(d, "OPTI_DUAL_G",SWIG_From_int(static_cast< int >(casadi::OPTI_DUAL_G)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

